@blackcode_sa/metaestetics-api 1.10.0 → 1.11.1

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@blackcode_sa/metaestetics-api",
   "private": false,
-  "version": "1.10.0",
+  "version": "1.11.1",
   "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/backoffice/expo-safe/index.ts

@@ -34,4 +34,6 @@ export {
 export { Contraindication } from "../types/static/contraindication.types";
 export { ProcedureFamily } from "../types/static/procedure-family.types";
 export { TreatmentBenefit } from "../types/static/treatment-benefit.types";
+export { TreatmentBenefitDynamic } from "../types/";
+export { ContraindicationDynamic } from "../types/";
 export { RequirementType, TimeUnit } from "../types/requirement.types";

package/src/backoffice/services/README.md

@@ -0,0 +1,40 @@
+# Backoffice Services
+
+This directory contains services used by the backoffice application.
+
+## Services
+
+### `CategoryService`
+
+Manages procedure categories. Categories are the first level of organization after procedure family (aesthetics/surgery).
+
+- **`create(category)`**: Creates a new category.
+- **`getAll()`**: Retrieves all active categories.
+- **`getAllByFamily(family)`**: Retrieves all active categories for a specific procedure family.
+- **`update(id, category)`**: Updates an existing category.
+- **`delete(id)`**: Soft deletes a category.
+- **`getById(id)`**: Retrieves a category by its ID.
+
+### `ProductService`
+
+Manages products, which are sub-items of a `Technology`.
+
+- **`create(technologyId, brandId, product)`**: Creates a new product under a technology.
+- **`getAllByTechnology(technologyId)`**: Retrieves all products for a technology.
+- **`getAllByBrand(brandId)`**: Retrieves all products for a brand.
+- **`update(technologyId, productId, product)`**: Updates a product.
+- **`delete(technologyId, productId)`**: Soft deletes a product.
+- **`getById(technologyId, productId)`**: Retrieves a product by its ID.
+
+### `ConstantsService`
+
+Manages administrative constants like treatment benefits and contraindications.
+
+- **`getTreatmentBenefits()`**: Retrieves all treatment benefits.
+- **`addTreatmentBenefit(benefit)`**: Adds a new treatment benefit.
+- **`updateTreatmentBenefit(benefit)`**: Updates an existing treatment benefit.
+- **`deleteTreatmentBenefit(benefitId)`**: Deletes a treatment benefit.
+- **`getContraindications()`**: Retrieves all contraindications.
+- **`addContraindication(contraindication)`**: Adds a new contraindication.
+- **`updateContraindication(contraindication)`**: Updates an existing contraindication.
+- **`deleteContraindication(contraindicationId)`**: Deletes a contraindication.