@blackcode_sa/metaestetics-api 1.8.18 → 1.11.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@blackcode_sa/metaestetics-api",
   "private": false,
-  "version": "1.8.18",
+  "version": "1.11.0",
   "description": "Firebase authentication service with anonymous upgrade support",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -83,6 +83,7 @@
   "devDependencies": {
     "@testing-library/jest-dom": "^6.6.3",
     "@types/jest": "^29.5.14",
+    "@types/luxon": "^3.7.1",
     "@types/mailgun-js": "^0.22.18",
     "@types/node": "^20.17.13",
     "@types/react": "^19.1.0",
@@ -98,6 +99,7 @@
     "expo-server-sdk": "^3.13.0",
     "firebase-admin": "^13.0.2",
     "geofire-common": "^6.0.0",
+    "luxon": "^3.7.1",
     "zod": "^3.24.1"
   },
   "optionalDependencies": {

package/src/admin/booking/booking.admin.ts

@@ -233,6 +233,7 @@ export class BookingAdmin {
         practitionerCalendarEvents: this.convertEventsTimestamps(
           practitionerCalendarEvents
         ),
+        tz: clinic.location.tz || "UTC",
       };
 
       Logger.info("[BookingAdmin] Calling availability calculator", {
@@ -823,6 +824,7 @@ export class BookingAdmin {
         calendarEventId: practitionerCalendarEventId,
         clinicBranchId: procedure.clinicBranchId,
         clinicInfo,
+        clinic_tz: clinicData.location.tz || "UTC",
         practitionerId: procedure.practitionerId,
         practitionerInfo,
         patientId: data.patientId,

package/src/admin/booking/booking.calculator.ts

@@ -1,4 +1,5 @@
 import { Timestamp } from "firebase/firestore";
+import { DateTime } from "luxon";
 import {
   BookingAvailabilityRequest,
   BookingAvailabilityResponse,
@@ -39,6 +40,7 @@ export class BookingAvailabilityCalculator {
       timeframe,
       clinicCalendarEvents,
       practitionerCalendarEvents,
+      tz,
     } = request;
 
     // Get scheduling interval (default to 15 minutes if not specified)
@@ -61,7 +63,8 @@ export class BookingAvailabilityCalculator {
     availableIntervals = this.applyClinicWorkingHours(
       availableIntervals,
       clinic.workingHours,
-      timeframe
+      timeframe,
+      tz
     );
 
     // Step 2: Subtract clinic blocking events
@@ -75,7 +78,8 @@ export class BookingAvailabilityCalculator {
       availableIntervals,
       practitioner,
       clinic.id,
-      timeframe
+      timeframe,
+      tz
     );
 
     // Step 4: Subtract practitioner's busy times
@@ -104,12 +108,14 @@ export 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(
     intervals: TimeInterval[],
     workingHours: any, // Using 'any' for now since we're working with the existing type structure
-    timeframe: { start: Timestamp; end: Timestamp }
+    timeframe: { start: Timestamp; end: Timestamp },
+    tz: string
   ): TimeInterval[] {
     if (!intervals.length) return [];
     console.log(
@@ -120,7 +126,8 @@ export class BookingAvailabilityCalculator {
     const workingIntervals = this.createWorkingHoursIntervals(
       workingHours,
       timeframe.start.toDate(),
-      timeframe.end.toDate()
+      timeframe.end.toDate(),
+      tz
     );
 
     // Intersect the available intervals with working hours intervals
@@ -133,44 +140,34 @@ export 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(
     workingHours: any,
     startDate: Date,
-    endDate: Date
+    endDate: Date,
+    tz: string
   ): TimeInterval[] {
     const workingIntervals: TimeInterval[] = [];
-
-    // Clone the start date to avoid modifying the original
-    const currentDate = new Date(startDate);
-
-    // Reset time to start of day
-    currentDate.setHours(0, 0, 0, 0);
-
-    // Create a map of day names to day numbers (0 = Sunday, 1 = Monday, etc.)
-    const dayNameToNumber: { [key: string]: number } = {
-      sunday: 0,
-      monday: 1,
-      tuesday: 2,
-      wednesday: 3,
-      thursday: 4,
-      friday: 5,
-      saturday: 6,
-    };
-
-    // Iterate through each day in the timeframe
-    while (currentDate <= endDate) {
-      const dayOfWeek = currentDate.getDay();
-      const dayName = Object.keys(dayNameToNumber).find(
-        (key) => dayNameToNumber[key] === dayOfWeek
-      );
+    let start = DateTime.fromJSDate(startDate, { zone: tz });
+    const end = DateTime.fromJSDate(endDate, { zone: tz });
+
+    while (start <= end) {
+      const dayOfWeek = start.weekday; // 1 for Monday, 7 for Sunday
+      const dayName = [
+        "monday",
+        "tuesday",
+        "wednesday",
+        "thursday",
+        "friday",
+        "saturday",
+        "sunday",
+      ][dayOfWeek - 1];
 
       if (dayName && workingHours[dayName]) {
         const daySchedule = workingHours[dayName];
-
         if (daySchedule) {
-          // Parse open and close times
           const [openHours, openMinutes] = daySchedule.open
             .split(":")
             .map(Number);
@@ -178,25 +175,37 @@ export class BookingAvailabilityCalculator {
             .split(":")
             .map(Number);
 
-          // Create start and end times for this working day
-          const workStart = new Date(currentDate);
-          workStart.setHours(openHours, openMinutes, 0, 0);
-
-          const workEnd = new Date(currentDate);
-          workEnd.setHours(closeHours, closeMinutes, 0, 0);
+          let workStart = start.set({
+            hour: openHours,
+            minute: openMinutes,
+            second: 0,
+            millisecond: 0,
+          });
+          let workEnd = start.set({
+            hour: closeHours,
+            minute: closeMinutes,
+            second: 0,
+            millisecond: 0,
+          });
 
-          // Only add if the working hours are within our timeframe
-          if (workEnd > startDate && workStart < endDate) {
-            // Adjust interval to be within our overall timeframe
-            const intervalStart = workStart < startDate ? startDate : workStart;
-            const intervalEnd = workEnd > endDate ? endDate : workEnd;
+          if (
+            workEnd.toMillis() > startDate.getTime() &&
+            workStart.toMillis() < endDate.getTime()
+          ) {
+            const intervalStart =
+              workStart < DateTime.fromJSDate(startDate, { zone: tz })
+                ? DateTime.fromJSDate(startDate, { zone: tz })
+                : workStart;
+            const intervalEnd =
+              workEnd > DateTime.fromJSDate(endDate, { zone: tz })
+                ? DateTime.fromJSDate(endDate, { zone: tz })
+                : workEnd;
 
             workingIntervals.push({
-              start: Timestamp.fromDate(intervalStart),
-              end: Timestamp.fromDate(intervalEnd),
+              start: Timestamp.fromMillis(intervalStart.toMillis()),
+              end: Timestamp.fromMillis(intervalEnd.toMillis()),
             });
 
-            // Handle breaks if they exist
             if (daySchedule.breaks && daySchedule.breaks.length > 0) {
               for (const breakTime of daySchedule.breaks) {
                 const [breakStartHours, breakStartMinutes] = breakTime.start
@@ -206,21 +215,23 @@ export class BookingAvailabilityCalculator {
                   .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,
+                });
 
-                // Subtract this break from our working intervals
                 workingIntervals.splice(
                   -1,
                   1,
                   ...this.subtractInterval(
                     workingIntervals[workingIntervals.length - 1],
                     {
-                      start: Timestamp.fromDate(breakStart),
-                      end: Timestamp.fromDate(breakEnd),
+                      start: Timestamp.fromMillis(breakStart.toMillis()),
+                      end: Timestamp.fromMillis(breakEnd.toMillis()),
                     }
                   )
                 );
@@ -229,11 +240,8 @@ export class BookingAvailabilityCalculator {
           }
         }
       }
-
-      // Move to the next day
-      currentDate.setDate(currentDate.getDate() + 1);
+      start = start.plus({ days: 1 });
     }
-
     return workingIntervals;
   }
 
@@ -290,13 +298,15 @@ export 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(
     intervals: TimeInterval[],
     practitioner: any,
     clinicId: string,
-    timeframe: { start: Timestamp; end: Timestamp }
+    timeframe: { start: Timestamp; end: Timestamp },
+    tz: string
   ): TimeInterval[] {
     if (!intervals.length) return [];
     console.log(`Applying practitioner working hours for clinic ${clinicId}`);
@@ -319,7 +329,8 @@ export class BookingAvailabilityCalculator {
     const workingIntervals = this.createPractitionerWorkingHoursIntervals(
       clinicWorkingHours.workingHours,
       timeframe.start.toDate(),
-      timeframe.end.toDate()
+      timeframe.end.toDate(),
+      tz
     );
 
     // Intersect the available intervals with practitioner's working hours intervals
@@ -332,74 +343,67 @@ export 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(
     workingHours: any,
     startDate: Date,
-    endDate: Date
+    endDate: Date,
+    tz: string
   ): TimeInterval[] {
     const workingIntervals: TimeInterval[] = [];
-
-    // Clone the start date to avoid modifying the original
-    const currentDate = new Date(startDate);
-
-    // Reset time to start of day
-    currentDate.setHours(0, 0, 0, 0);
-
-    // Create a map of day names to day numbers (0 = Sunday, 1 = Monday, etc.)
-    const dayNameToNumber: { [key: string]: number } = {
-      sunday: 0,
-      monday: 1,
-      tuesday: 2,
-      wednesday: 3,
-      thursday: 4,
-      friday: 5,
-      saturday: 6,
-    };
-
-    // Iterate through each day in the timeframe
-    while (currentDate <= endDate) {
-      const dayOfWeek = currentDate.getDay();
-      const dayName = Object.keys(dayNameToNumber).find(
-        (key) => dayNameToNumber[key] === dayOfWeek
-      );
+    let start = DateTime.fromJSDate(startDate, { zone: tz });
+    const end = 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) {
-          // Parse start and end times
           const [startHours, startMinutes] = daySchedule.start
             .split(":")
             .map(Number);
           const [endHours, endMinutes] = daySchedule.end.split(":").map(Number);
 
-          // Create start and end times for this working day
-          const workStart = new Date(currentDate);
-          workStart.setHours(startHours, startMinutes, 0, 0);
-
-          const workEnd = new Date(currentDate);
-          workEnd.setHours(endHours, endMinutes, 0, 0);
-
-          // Only add if the working hours are within our timeframe
-          if (workEnd > startDate && workStart < endDate) {
-            // Adjust interval to be within our overall timeframe
-            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 < DateTime.fromJSDate(startDate, { zone: tz })
+                ? DateTime.fromJSDate(startDate, { zone: tz })
+                : workStart;
+            const intervalEnd =
+              workEnd > DateTime.fromJSDate(endDate, { zone: tz })
+                ? DateTime.fromJSDate(endDate, { zone: tz })
+                : workEnd;
 
             workingIntervals.push({
-              start: Timestamp.fromDate(intervalStart),
-              end: Timestamp.fromDate(intervalEnd),
+              start: Timestamp.fromMillis(intervalStart.toMillis()),
+              end: Timestamp.fromMillis(intervalEnd.toMillis()),
             });
           }
         }
       }
-
-      // Move to the next day
-      currentDate.setDate(currentDate.getDate() + 1);
+      start = start.plus({ days: 1 });
     }
-
     return workingIntervals;
   }
 
@@ -485,32 +489,32 @@ export class BookingAvailabilityCalculator {
       const intervalEnd = interval.end.toDate();
 
       // Start at the beginning of the interval
-      let slotStart = new Date(intervalStart);
+      let slotStart = DateTime.fromJSDate(intervalStart);
 
       // Adjust slotStart to the nearest interval boundary if needed
-      const minutesIntoDay = slotStart.getHours() * 60 + slotStart.getMinutes();
+      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,
+        });
       }
 
       // Iterate through potential start times
-      while (slotStart.getTime() + durationMs <= intervalEnd.getTime()) {
+      while (slotStart.toMillis() + durationMs <= intervalEnd.getTime()) {
         // Calculate potential end time
-        const slotEnd = new Date(slotStart.getTime() + durationMs);
+        const slotEnd = slotStart.plus({ minutes: durationMinutes });
 
         // Check if this slot fits entirely within one of our available intervals
         if (this.isSlotFullyAvailable(slotStart, slotEnd, intervals)) {
           slots.push({
-            start: Timestamp.fromDate(slotStart),
+            start: Timestamp.fromMillis(slotStart.toMillis()),
           });
         }
 
         // Move to the next potential start time
-        slotStart = new Date(slotStart.getTime() + intervalMs);
+        slotStart = slotStart.plus({ minutes: intervalMinutes });
       }
     }
 
@@ -527,14 +531,14 @@ export class BookingAvailabilityCalculator {
    * @returns True if the slot is fully contained within an available interval
    */
   private static isSlotFullyAvailable(
-    slotStart: Date,
-    slotEnd: Date,
+    slotStart: DateTime,
+    slotEnd: DateTime,
     intervals: TimeInterval[]
   ): boolean {
     // Check if the slot is fully contained in any of the available intervals
     return intervals.some((interval) => {
-      const intervalStart = interval.start.toDate();
-      const intervalEnd = interval.end.toDate();
+      const intervalStart = DateTime.fromMillis(interval.start.toMillis());
+      const intervalEnd = DateTime.fromMillis(interval.end.toMillis());
 
       return slotStart >= intervalStart && slotEnd <= intervalEnd;
     });

package/src/admin/booking/booking.types.ts

@@ -28,6 +28,9 @@ export interface BookingAvailabilityRequest {
 
   /** Calendar events for the practitioner during the specified timeframe */
   practitionerCalendarEvents: CalendarEvent[];
+
+  /** IANA timezone of the clinic */
+  tz: string;
 }
 
 /**

package/src/services/clinic/clinic.service.ts

@@ -17,6 +17,7 @@ import {
   arrayUnion,
   arrayRemove,
 } from "firebase/firestore";
+import { getFunctions, httpsCallable } from "firebase/functions";
 import { BaseService } from "../base.service";
 import {
   Clinic,
@@ -63,6 +64,7 @@ export class ClinicService extends BaseService {
   private clinicGroupService: ClinicGroupService;
   private clinicAdminService: ClinicAdminService;
   private mediaService: MediaService;
+  private functions: any;
 
   constructor(
     db: Firestore,
@@ -76,6 +78,28 @@ export class ClinicService extends BaseService {
     this.clinicAdminService = clinicAdminService;
     this.clinicGroupService = clinicGroupService;
     this.mediaService = mediaService;
+    this.functions = getFunctions(app);
+  }
+
+  /**
+   * Get timezone from coordinates using the callable function
+   * @param lat Latitude
+   * @param lng Longitude
+   * @returns IANA timezone string
+   */
+  private async getTimezone(lat: number, lng: number): Promise<string | null> {
+    try {
+      const getTimezoneFromCoordinates = httpsCallable(
+        this.functions,
+        "getTimezoneFromCoordinates"
+      );
+      const result = await getTimezoneFromCoordinates({ lat, lng });
+      const data = result.data as { timezone: string };
+      return data.timezone;
+    } catch (error) {
+      console.error("Error getting timezone:", error);
+      return null;
+    }
   }
 
   /**
@@ -225,6 +249,7 @@ export class ClinicService extends BaseService {
 
       const location = validatedData.location;
       const hash = geohashForLocation([location.latitude, location.longitude]);
+      const tz = await this.getTimezone(location.latitude, location.longitude);
 
       const defaultReviewInfo: ClinicReviewInfo = {
         totalReviews: 0,
@@ -246,7 +271,7 @@ export class ClinicService extends BaseService {
         name: validatedData.name,
         nameLower: validatedData.name.toLowerCase(), // Add this line
         description: validatedData.description,
-        location: { ...location, geohash: hash },
+        location: { ...location, geohash: hash, tz },
         contactInfo: validatedData.contactInfo,
         workingHours: validatedData.workingHours,
         tags: validatedData.tags,
@@ -393,9 +418,11 @@ export class ClinicService extends BaseService {
       // Handle location update with geohash
       if (validatedData.location) {
         const loc = validatedData.location;
+        const tz = await this.getTimezone(loc.latitude, loc.longitude);
         updatePayload.location = {
           ...loc,
           geohash: geohashForLocation([loc.latitude, loc.longitude]),
+          tz,
         };
       }
 
@@ -643,6 +670,7 @@ export class ClinicService extends BaseService {
     procedureTechnology?: string;
     minRating?: number;
     maxRating?: number;
+    nameSearch?: string;
     pagination?: number;
     lastDoc?: any;
     isActive?: boolean;
@@ -658,21 +686,23 @@ export class ClinicService extends BaseService {
    * This is optimized for mobile map usage to reduce payload size.
    * @returns Array of minimal clinic info for map
    */
-  async getClinicsForMap(): Promise<{
-    id: string;
-    name: string;
-    address: string;
-    latitude: number | undefined;
-    longitude: number | undefined;
-  }[]> {
+  async getClinicsForMap(): Promise<
+    {
+      id: string;
+      name: string;
+      address: string;
+      latitude: number | undefined;
+      longitude: number | undefined;
+    }[]
+  > {
     const clinicsRef = collection(this.db, CLINICS_COLLECTION);
     const snapshot = await getDocs(clinicsRef);
-    const clinicsForMap = snapshot.docs.map(doc => {
+    const clinicsForMap = snapshot.docs.map((doc) => {
       const data = doc.data();
       return {
         id: doc.id,
         name: data.name,
-        address: data.location?.address || '',
+        address: data.location?.address || "",
         latitude: data.location?.latitude,
         longitude: data.location?.longitude,
       };