@blackcode_sa/metaestetics-api 1.5.32 → 1.5.33

package/dist/index.d.ts

@@ -850,6 +850,8 @@ interface ProcedureSummaryInfo {
     categoryName: string;
     subcategoryName: string;
     technologyName: string;
+    brandName?: string;
+    productName?: string;
     price: number;
     pricingMeasure: PricingMeasure;
     currency: Currency;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@blackcode_sa/metaestetics-api",
   "private": false,
-  "version": "1.5.32",
+  "version": "1.5.33",
   "description": "Firebase authentication service with anonymous upgrade support",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",

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

@@ -0,0 +1,234 @@
+import * as admin from "firebase-admin";
+import {
+  BookingAvailabilityCalculator,
+  BookingAvailabilityRequest,
+  BookingAvailabilityResponse,
+  AvailableSlot,
+} from "./";
+import { CalendarEventStatus, CalendarEventType } from "../../types/calendar";
+import { Clinic } from "../../types/clinic";
+import { Practitioner } from "../../types/practitioner";
+import { Procedure } from "../../types/procedure";
+
+/**
+ * Admin service for handling booking-related operations.
+ * This is the cloud-based implementation that will be used in Cloud Functions.
+ */
+export class BookingAdmin {
+  private db: admin.firestore.Firestore;
+
+  /**
+   * Creates a new BookingAdmin instance
+   * @param firestore - Firestore instance provided by the caller
+   */
+  constructor(firestore?: admin.firestore.Firestore) {
+    this.db = firestore || admin.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: string,
+    practitionerId: string,
+    procedureId: string,
+    timeframe: {
+      start: Date | admin.firestore.Timestamp;
+      end: Date | admin.firestore.Timestamp;
+    }
+  ): Promise<{ availableSlots: { start: admin.firestore.Timestamp }[] }> {
+    try {
+      console.log(
+        `[BookingAdmin] Getting available slots for clinic ${clinicId}, practitioner ${practitionerId}, procedure ${procedureId}`
+      );
+
+      // Convert timeframe dates to Firestore Timestamps if needed
+      const start =
+        timeframe.start instanceof Date
+          ? admin.firestore.Timestamp.fromDate(timeframe.start)
+          : timeframe.start;
+
+      const end =
+        timeframe.end instanceof Date
+          ? admin.firestore.Timestamp.fromDate(timeframe.end)
+          : timeframe.end;
+
+      // 1. Fetch clinic data
+      const clinicDoc = await this.db.collection("clinics").doc(clinicId).get();
+      if (!clinicDoc.exists) {
+        throw new Error(`Clinic ${clinicId} not found`);
+      }
+      const clinic = clinicDoc.data() as unknown as Clinic;
+
+      // 2. Fetch practitioner 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() as unknown as Practitioner;
+
+      // 3. Fetch procedure 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() as unknown as Procedure;
+
+      // 4. Fetch clinic calendar events
+      const clinicCalendarEvents = await this.getClinicCalendarEvents(
+        clinicId,
+        start,
+        end
+      );
+
+      // 5. Fetch practitioner calendar events
+      const practitionerCalendarEvents =
+        await this.getPractitionerCalendarEvents(practitionerId, start, end);
+
+      // Since we're working with two different Timestamp implementations (admin vs client),
+      // we need to convert our timestamps to the client-side format expected by the calculator
+      // Create client Timestamp objects from admin Timestamp objects
+      const convertedTimeframe = {
+        start: this.adminTimestampToClientTimestamp(start),
+        end: this.adminTimestampToClientTimestamp(end),
+      };
+
+      // Create the request object for the calculator
+      const request: BookingAvailabilityRequest = {
+        clinic,
+        practitioner,
+        procedure,
+        timeframe: convertedTimeframe,
+        clinicCalendarEvents:
+          this.convertEventsTimestamps(clinicCalendarEvents),
+        practitionerCalendarEvents: this.convertEventsTimestamps(
+          practitionerCalendarEvents
+        ),
+      };
+
+      // Use the calculator to compute available slots
+      const result = BookingAvailabilityCalculator.calculateSlots(request);
+
+      // Convert the client Timestamps to admin Timestamps before returning
+      return {
+        availableSlots: result.availableSlots.map((slot) => ({
+          start: admin.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
+   */
+  private adminTimestampToClientTimestamp(
+    timestamp: admin.firestore.Timestamp
+  ): any {
+    // Create a client Timestamp with the same seconds and nanoseconds
+    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
+   */
+  private convertEventsTimestamps(events: any[]): any[] {
+    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
+   */
+  private async getClinicCalendarEvents(
+    clinicId: string,
+    start: admin.firestore.Timestamp,
+    end: admin.firestore.Timestamp
+  ): Promise<any[]> {
+    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
+   */
+  private async getPractitionerCalendarEvents(
+    practitionerId: string,
+    start: admin.firestore.Timestamp,
+    end: admin.firestore.Timestamp
+  ): Promise<any[]> {
+    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 [];
+    }
+  }
+}