@blackcode_sa/metaestetics-api 1.7.13 → 1.7.15

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

@@ -64,6 +64,7 @@ import {
 import { DocumentManagerAdminService } from "../documentation-templates/document-manager.admin";
 import { LinkedFormInfo } from "../../types/appointment";
 import { TimestampUtils } from "../../utils/TimestampUtils";
+import { Logger } from "../logger";
 
 /**
  * Interface for the data required by orchestrateAppointmentCreation
@@ -112,9 +113,19 @@ export class BookingAdmin {
     }
   ): Promise<{ availableSlots: { start: admin.firestore.Timestamp }[] }> {
     try {
-      console.log(
-        `[BookingAdmin] Getting available slots for clinic ${clinicId}, practitioner ${practitionerId}, procedure ${procedureId}`
-      );
+      Logger.info("[BookingAdmin] Starting availability calculation", {
+        clinicId,
+        practitionerId,
+        procedureId,
+        timeframeStart:
+          timeframe.start instanceof Date
+            ? timeframe.start.toISOString()
+            : timeframe.start.toDate().toISOString(),
+        timeframeEnd:
+          timeframe.end instanceof Date
+            ? timeframe.end.toISOString()
+            : timeframe.end.toDate().toISOString(),
+      });
 
       // Convert timeframe dates to Firestore Timestamps if needed
       const start =
@@ -128,42 +139,80 @@ export class BookingAdmin {
           : timeframe.end;
 
       // 1. Fetch clinic data
+      Logger.debug("[BookingAdmin] Fetching clinic data", { clinicId });
       const clinicDoc = await this.db.collection("clinics").doc(clinicId).get();
       if (!clinicDoc.exists) {
+        Logger.error("[BookingAdmin] Clinic not found", { clinicId });
         throw new Error(`Clinic ${clinicId} not found`);
       }
       const clinic = clinicDoc.data() as unknown as Clinic;
+      Logger.debug("[BookingAdmin] Retrieved clinic data", {
+        clinicName: clinic.name,
+        clinicHasWorkingHours: !!clinic.workingHours,
+      });
 
       // 2. Fetch practitioner data
+      Logger.debug("[BookingAdmin] Fetching practitioner data", {
+        practitionerId,
+      });
       const practitionerDoc = await this.db
         .collection("practitioners")
         .doc(practitionerId)
         .get();
       if (!practitionerDoc.exists) {
+        Logger.error("[BookingAdmin] Practitioner not found", {
+          practitionerId,
+        });
         throw new Error(`Practitioner ${practitionerId} not found`);
       }
       const practitioner = practitionerDoc.data() as unknown as Practitioner;
+      Logger.debug("[BookingAdmin] Retrieved practitioner data", {
+        practitionerName: `${practitioner.basicInfo.firstName} ${practitioner.basicInfo.lastName}`,
+        pracWorkingHoursCount: practitioner.clinicWorkingHours?.length || 0,
+      });
 
       // 3. Fetch procedure data
+      Logger.debug("[BookingAdmin] Fetching procedure data", { procedureId });
       const procedureDoc = await this.db
         .collection("procedures")
         .doc(procedureId)
         .get();
       if (!procedureDoc.exists) {
+        Logger.error("[BookingAdmin] Procedure not found", { procedureId });
         throw new Error(`Procedure ${procedureId} not found`);
       }
       const procedure = procedureDoc.data() as unknown as Procedure;
+      Logger.debug("[BookingAdmin] Retrieved procedure data", {
+        procedureName: procedure.name,
+        procedureDuration: procedure.duration,
+      });
 
       // 4. Fetch clinic calendar events
+      Logger.debug("[BookingAdmin] Fetching clinic calendar events", {
+        clinicId,
+        startTime: start.toDate().toISOString(),
+        endTime: end.toDate().toISOString(),
+      });
       const clinicCalendarEvents = await this.getClinicCalendarEvents(
         clinicId,
         start,
         end
       );
+      Logger.debug("[BookingAdmin] Retrieved clinic calendar events", {
+        count: clinicCalendarEvents.length,
+      });
 
       // 5. Fetch practitioner calendar events
+      Logger.debug("[BookingAdmin] Fetching practitioner calendar events", {
+        practitionerId,
+        startTime: start.toDate().toISOString(),
+        endTime: end.toDate().toISOString(),
+      });
       const practitionerCalendarEvents =
         await this.getPractitionerCalendarEvents(practitionerId, start, end);
+      Logger.debug("[BookingAdmin] Retrieved practitioner calendar events", {
+        count: practitionerCalendarEvents.length,
+      });
 
       // 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
@@ -186,17 +235,57 @@ export class BookingAdmin {
         ),
       };
 
+      Logger.info("[BookingAdmin] Calling availability calculator", {
+        calculatorInputReady: true,
+        timeframeDurationHours: Math.round(
+          (end.toMillis() - start.toMillis()) / (1000 * 60 * 60)
+        ),
+        clinicEventsCount: clinicCalendarEvents.length,
+        practitionerEventsCount: practitionerCalendarEvents.length,
+      });
+
       // Use the calculator to compute available slots
       const result = BookingAvailabilityCalculator.calculateSlots(request);
 
       // Convert the client Timestamps to admin Timestamps before returning
-      return {
+      const availableSlotsResult = {
         availableSlots: result.availableSlots.map((slot) => ({
           start: admin.firestore.Timestamp.fromMillis(slot.start.toMillis()),
         })),
       };
+
+      Logger.info(
+        "[BookingAdmin] Availability calculation completed successfully",
+        {
+          availableSlotsCount: availableSlotsResult.availableSlots.length,
+          firstSlotTime:
+            availableSlotsResult.availableSlots.length > 0
+              ? availableSlotsResult.availableSlots[0].start
+                  .toDate()
+                  .toISOString()
+              : "none",
+          lastSlotTime:
+            availableSlotsResult.availableSlots.length > 0
+              ? availableSlotsResult.availableSlots[
+                  availableSlotsResult.availableSlots.length - 1
+                ].start
+                  .toDate()
+                  .toISOString()
+              : "none",
+        }
+      );
+
+      return availableSlotsResult;
     } catch (error) {
-      console.error("[BookingAdmin] Error getting available slots:", error);
+      const errorMessage =
+        error instanceof Error ? error.message : String(error);
+      Logger.error("[BookingAdmin] Error getting available slots", {
+        errorMessage,
+        clinicId,
+        practitionerId,
+        procedureId,
+        stack: error instanceof Error ? error.stack : undefined,
+      });
       throw error;
     }
   }
@@ -243,6 +332,12 @@ export class BookingAdmin {
     end: admin.firestore.Timestamp
   ): Promise<any[]> {
     try {
+      Logger.debug("[BookingAdmin] Querying clinic calendar events", {
+        clinicId,
+        startTime: start.toDate().toISOString(),
+        endTime: end.toDate().toISOString(),
+      });
+
       const eventsRef = this.db
         .collection(`clinics/${clinicId}/calendar`)
         .where("eventTime.start", ">=", start)
@@ -250,15 +345,28 @@ export class BookingAdmin {
 
       const snapshot = await eventsRef.get();
 
-      return snapshot.docs.map((doc) => ({
+      const events = snapshot.docs.map((doc) => ({
         ...doc.data(),
         id: doc.id,
       }));
+
+      Logger.debug("[BookingAdmin] Retrieved clinic calendar events", {
+        clinicId,
+        eventsCount: events.length,
+        eventsTypes: this.summarizeEventTypes(events),
+      });
+
+      return events;
     } catch (error) {
-      console.error(
-        `[BookingAdmin] Error fetching clinic calendar events:`,
-        error
-      );
+      const errorMessage =
+        error instanceof Error ? error.message : String(error);
+      Logger.error("[BookingAdmin] Error fetching clinic calendar events", {
+        errorMessage,
+        clinicId,
+        startTime: start.toDate().toISOString(),
+        endTime: end.toDate().toISOString(),
+        stack: error instanceof Error ? error.stack : undefined,
+      });
       return [];
     }
   }
@@ -277,6 +385,12 @@ export class BookingAdmin {
     end: admin.firestore.Timestamp
   ): Promise<any[]> {
     try {
+      Logger.debug("[BookingAdmin] Querying practitioner calendar events", {
+        practitionerId,
+        startTime: start.toDate().toISOString(),
+        endTime: end.toDate().toISOString(),
+      });
+
       const eventsRef = this.db
         .collection(`practitioners/${practitionerId}/calendar`)
         .where("eventTime.start", ">=", start)
@@ -284,19 +398,51 @@ export class BookingAdmin {
 
       const snapshot = await eventsRef.get();
 
-      return snapshot.docs.map((doc) => ({
+      const events = snapshot.docs.map((doc) => ({
         ...doc.data(),
         id: doc.id,
       }));
+
+      Logger.debug("[BookingAdmin] Retrieved practitioner calendar events", {
+        practitionerId,
+        eventsCount: events.length,
+        eventsTypes: this.summarizeEventTypes(events),
+      });
+
+      return events;
     } catch (error) {
-      console.error(
-        `[BookingAdmin] Error fetching practitioner calendar events:`,
-        error
+      const errorMessage =
+        error instanceof Error ? error.message : String(error);
+      Logger.error(
+        "[BookingAdmin] Error fetching practitioner calendar events",
+        {
+          errorMessage,
+          practitionerId,
+          startTime: start.toDate().toISOString(),
+          endTime: end.toDate().toISOString(),
+          stack: error instanceof Error ? error.stack : undefined,
+        }
       );
       return [];
     }
   }
 
+  /**
+   * Summarizes event types for logging purposes
+   * @param events Array of calendar events
+   * @returns Object with counts of each event type
+   */
+  private summarizeEventTypes(events: any[]): Record<string, number> {
+    const typeCounts: Record<string, number> = {};
+
+    events.forEach((event) => {
+      const eventType = event.eventType || "unknown";
+      typeCounts[eventType] = (typeCounts[eventType] || 0) + 1;
+    });
+
+    return typeCounts;
+  }
+
   private _generateCalendarProcedureInfo(
     procedure: Procedure
   ): CalendarProcedureInfo {

package/src/services/procedure/procedure.service.ts

@@ -70,12 +70,14 @@ import { Clinic, CLINICS_COLLECTION } from "../../types/clinic";
 import { ProcedureReviewInfo } from "../../types/reviews";
 import { distanceBetween, geohashQueryBounds } from "geofire-common";
 import { TreatmentBenefit } from "../../backoffice/types/static/treatment-benefit.types";
+import { MediaService, MediaAccessLevel } from "../media/media.service";
 
 export class ProcedureService extends BaseService {
   private categoryService: CategoryService;
   private subcategoryService: SubcategoryService;
   private technologyService: TechnologyService;
   private productService: ProductService;
+  private mediaService: MediaService;
 
   constructor(
     db: Firestore,
@@ -84,13 +86,81 @@ export class ProcedureService extends BaseService {
     categoryService: CategoryService,
     subcategoryService: SubcategoryService,
     technologyService: TechnologyService,
-    productService: ProductService
+    productService: ProductService,
+    mediaService: MediaService
   ) {
     super(db, auth, app);
     this.categoryService = categoryService;
     this.subcategoryService = subcategoryService;
     this.technologyService = technologyService;
     this.productService = productService;
+    this.mediaService = mediaService;
+  }
+
+  /**
+   * Process media resource (string URL or File object)
+   * @param media String URL or File object
+   * @param ownerId Owner ID for the media (usually procedureId)
+   * @param collectionName Collection name for organizing files
+   * @returns URL string after processing
+   */
+  private async processMedia(
+    media: string | File | Blob | null | undefined,
+    ownerId: string,
+    collectionName: string
+  ): Promise<string | null> {
+    if (!media) return null;
+
+    // If already a string URL, return it directly
+    if (typeof media === "string") {
+      return media;
+    }
+
+    // If it's a File, upload it using MediaService
+    if (media instanceof File || media instanceof Blob) {
+      console.log(
+        `[ProcedureService] Uploading ${collectionName} media for ${ownerId}`
+      );
+      const metadata = await this.mediaService.uploadMedia(
+        media,
+        ownerId,
+        MediaAccessLevel.PUBLIC,
+        collectionName
+      );
+      return metadata.url;
+    }
+
+    return null;
+  }
+
+  /**
+   * Process array of media resources (strings or Files)
+   * @param mediaArray Array of string URLs or File objects
+   * @param ownerId Owner ID for the media
+   * @param collectionName Collection name for organizing files
+   * @returns Array of URL strings after processing
+   */
+  private async processMediaArray(
+    mediaArray: (string | File | Blob)[] | undefined,
+    ownerId: string,
+    collectionName: string
+  ): Promise<string[]> {
+    if (!mediaArray || mediaArray.length === 0) return [];
+
+    const result: string[] = [];
+
+    for (const media of mediaArray) {
+      const processedUrl = await this.processMedia(
+        media,
+        ownerId,
+        collectionName
+      );
+      if (processedUrl) {
+        result.push(processedUrl);
+      }
+    }
+
+    return result;
   }
 
   /**
@@ -101,6 +171,9 @@ export class ProcedureService extends BaseService {
   async createProcedure(data: CreateProcedureData): Promise<Procedure> {
     const validatedData = createProcedureSchema.parse(data);
 
+    // Generate procedure ID first so we can use it for media uploads
+    const procedureId = this.generateId();
+
     // Get references to related entities (Category, Subcategory, Technology, Product)
     const [category, subcategory, technology, product] = await Promise.all([
       this.categoryService.getById(validatedData.categoryId),
@@ -146,6 +219,16 @@ export class ProcedureService extends BaseService {
     }
     const practitioner = practitionerSnapshot.data() as Practitioner; // Assert type
 
+    // Process photos if provided
+    let processedPhotos: string[] = [];
+    if (validatedData.photos && validatedData.photos.length > 0) {
+      processedPhotos = await this.processMediaArray(
+        validatedData.photos,
+        procedureId,
+        "procedure-photos"
+      );
+    }
+
     // Create aggregated clinic info for the procedure document
     const clinicInfo = {
       id: clinicSnapshot.id,
@@ -174,10 +257,10 @@ export class ProcedureService extends BaseService {
     };
 
     // Create the procedure object
-    const procedureId = this.generateId();
     const newProcedure: Omit<Procedure, "createdAt" | "updatedAt"> = {
       id: procedureId,
       ...validatedData,
+      photos: processedPhotos,
       category, // Embed full objects
       subcategory,
       technology,
@@ -296,6 +379,15 @@ export class ProcedureService extends BaseService {
     let newPractitioner: Practitioner | null = null;
     let newClinic: Clinic | null = null;
 
+    // Process photos if provided
+    if (validatedData.photos !== undefined) {
+      updatedProcedureData.photos = await this.processMediaArray(
+        validatedData.photos,
+        id,
+        "procedure-photos"
+      );
+    }
+
     // --- Prepare updates and fetch new related data if IDs change ---
 
     // Handle Practitioner Change

package/src/types/procedure/index.ts

@@ -20,6 +20,7 @@ import { DoctorInfo } from "../clinic";
 import { PRACTITIONERS_COLLECTION } from "../practitioner";
 import { ProcedureReviewInfo } from "../reviews";
 import type { Contraindication } from "../../backoffice/types/static/contraindication.types";
+import { MediaResource } from "../../services/media/media.service";
 
 /**
  * Procedure represents a specific medical procedure that can be performed by a practitioner in a clinic
@@ -31,7 +32,7 @@ export interface Procedure {
   /** Name of the procedure */
   name: string;
   /** Photos of the procedure */
-  photos?: string[];
+  photos?: MediaResource[];
   /** Detailed description of the procedure */
   description: string;
   /** Family of procedures this belongs to (aesthetics/surgery) */
@@ -101,7 +102,7 @@ export interface CreateProcedureData {
   duration: number;
   practitionerId: string;
   clinicBranchId: string;
-  photos?: string[];
+  photos?: MediaResource[];
 }
 
 /**
@@ -121,7 +122,7 @@ export interface UpdateProcedureData {
   technologyId?: string;
   productId?: string;
   clinicBranchId?: string;
-  photos?: string[];
+  photos?: MediaResource[];
 }
 
 /**

package/src/validations/procedure.schema.ts

@@ -6,7 +6,7 @@ import {
 } from "../backoffice/types/static/pricing.types";
 import { clinicInfoSchema, doctorInfoSchema } from "./shared.schema";
 import { procedureReviewInfoSchema } from "./reviews.schema";
-
+import { mediaResourceSchema } from "./media.schema";
 /**
  * Schema for creating a new procedure
  */
@@ -24,7 +24,7 @@ export const createProcedureSchema = z.object({
   duration: z.number().min(1).max(480), // Max 8 hours
   practitionerId: z.string().min(1),
   clinicBranchId: z.string().min(1),
-  photos: z.array(z.string()).optional(),
+  photos: z.array(mediaResourceSchema).optional(),
 });
 
 /**
@@ -44,7 +44,7 @@ export const updateProcedureSchema = z.object({
   technologyId: z.string().optional(),
   productId: z.string().optional(),
   clinicBranchId: z.string().optional(),
-  photos: z.array(z.string()).optional(),
+  photos: z.array(mediaResourceSchema).optional(),
 });
 
 /**