@blackcode_sa/metaestetics-api 1.6.4 → 1.6.5

package/src/services/appointment/appointment.service.ts

@@ -93,100 +93,6 @@ export class AppointmentService extends BaseService {
     this.functions = getFunctions(app, "europe-west6"); // Initialize Firebase Functions with the correct region
   }
 
-  /**
-   * Test method using the callable function version of getAvailableBookingSlots
-   * For development and testing purposes only - not for production use
-   *
-   * @param clinicId ID of the clinic
-   * @param practitionerId ID of the practitioner
-   * @param procedureId ID of the procedure
-   * @param startDate Start date of the time range to check
-   * @param endDate End date of the time range to check
-   * @returns Test result from the callable function
-   */
-  async testGetAvailableBookingSlots(
-    clinicId: string,
-    practitionerId: string,
-    procedureId: string,
-    startDate: Date,
-    endDate: Date
-  ): Promise<any> {
-    try {
-      console.log(
-        `[APPOINTMENT_SERVICE] Testing callable function for clinic: ${clinicId}, practitioner: ${practitionerId}, procedure: ${procedureId}`
-      );
-
-      // Get the callable function
-      const getAvailableBookingSlotsCallable = httpsCallable(
-        this.functions,
-        "getAvailableBookingSlots"
-      );
-
-      // Call the function with the required parameters
-      const result = await getAvailableBookingSlotsCallable({
-        clinicId,
-        practitionerId,
-        procedureId,
-        timeframe: {
-          start: startDate.getTime(),
-          end: endDate.getTime(),
-        },
-      });
-
-      console.log(
-        "[APPOINTMENT_SERVICE] Callable function test result:",
-        result.data
-      );
-
-      return result.data;
-    } catch (error) {
-      console.error(
-        "[APPOINTMENT_SERVICE] Error testing callable function:",
-        error
-      );
-      throw error;
-    }
-  }
-
-  /**
-   * Gets available booking 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 startDate Start date of the time range to check
-   * @param endDate End date of the time range to check
-   * @returns Array of available booking slots
-   */
-  async getAvailableBookingSlots(
-    clinicId: string,
-    practitionerId: string,
-    procedureId: string,
-    startDate: Date,
-    endDate: Date
-  ): Promise<AvailableSlot[]> {
-    try {
-      console.log(
-        `[APPOINTMENT_SERVICE] Getting available booking slots for clinic: ${clinicId}, practitioner: ${practitionerId}, procedure: ${procedureId}`
-      );
-
-      // Just call our HTTP implementation since the callable function isn't working in the browser
-      return this.getAvailableBookingSlotsHttp(
-        clinicId,
-        practitionerId,
-        procedureId,
-        startDate,
-        endDate
-      );
-    } catch (error) {
-      console.error(
-        "[APPOINTMENT_SERVICE] Error getting available booking slots:",
-        error
-      );
-      throw error;
-    }
-  }
-
   /**
    * Gets available booking slots for a specific clinic, practitioner, and procedure using HTTP request.
    * This is an alternative implementation using direct HTTP request instead of callable function.
@@ -328,42 +234,108 @@ export class AppointmentService extends BaseService {
   }
 
   /**
-   * Creates a new appointment.
+   * Creates an appointment via the Cloud Function orchestrateAppointmentCreation
    *
-   * @param data Data needed to create the appointment
+   * @param data - CreateAppointmentData object
    * @returns The created appointment
    */
-  async createAppointment(data: CreateAppointmentData): Promise<Appointment> {
+  async createAppointmentHttp(
+    data: CreateAppointmentData
+  ): Promise<Appointment> {
     try {
-      console.log("[APPOINTMENT_SERVICE] Creating appointment");
+      console.log(
+        "[APPOINTMENT_SERVICE] Creating appointment via cloud function"
+      );
 
-      // Validate input data
-      const validatedData = await createAppointmentSchema.parseAsync(data);
+      // Get the authenticated user's ID token
+      const currentUser = this.auth.currentUser;
+      if (!currentUser) {
+        throw new Error("User must be authenticated to create an appointment");
+      }
+      const idToken = await currentUser.getIdToken();
 
-      // Fetch all required aggregated information
-      const aggregatedInfo = await fetchAggregatedInfoUtil(
-        this.db,
-        validatedData.clinicBranchId,
-        validatedData.practitionerId,
-        validatedData.patientId,
-        validatedData.procedureId
-      );
+      // Construct the function URL for the Express app endpoint
+      const functionUrl = `https://europe-west6-metaestetics.cloudfunctions.net/bookingApi/orchestrateAppointmentCreation`;
 
-      // Create the appointment using the utility function
-      const appointment = await createAppointmentUtil(
-        this.db,
-        validatedData as CreateAppointmentData,
-        aggregatedInfo,
-        this.generateId.bind(this)
+      // Prepare request data for the Cloud Function
+      // Map CreateAppointmentData to OrchestrateAppointmentCreationData format
+      const requestData = {
+        patientId: data.patientId,
+        procedureId: data.procedureId,
+        appointmentStartTime: data.appointmentStartTime.toMillis
+          ? data.appointmentStartTime.toMillis()
+          : new Date(data.appointmentStartTime as any).getTime(),
+        appointmentEndTime: data.appointmentEndTime.toMillis
+          ? data.appointmentEndTime.toMillis()
+          : new Date(data.appointmentEndTime as any).getTime(),
+        patientNotes: data.patientNotes || null,
+      };
+
+      console.log(
+        `[APPOINTMENT_SERVICE] Making fetch request to ${functionUrl}`
       );
 
+      // Make the HTTP request with expanded CORS options for browser
+      const response = await fetch(functionUrl, {
+        method: "POST",
+        mode: "cors",
+        cache: "no-cache",
+        credentials: "omit",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${idToken}`,
+        },
+        redirect: "follow",
+        referrerPolicy: "no-referrer",
+        body: JSON.stringify(requestData),
+      });
+
       console.log(
-        `[APPOINTMENT_SERVICE] Appointment created with ID: ${appointment.id}`
+        `[APPOINTMENT_SERVICE] Received response ${response.status}: ${response.statusText}`
       );
 
-      return appointment;
+      // Check if the request was successful
+      if (!response.ok) {
+        const errorText = await response.text();
+        console.error(
+          `[APPOINTMENT_SERVICE] Error response details: ${errorText}`
+        );
+        throw new Error(
+          `Failed to create appointment: ${response.status} ${response.statusText} - ${errorText}`
+        );
+      }
+
+      // Parse the response
+      const result = await response.json();
+
+      if (!result.success) {
+        throw new Error(result.error || "Failed to create appointment");
+      }
+
+      // If the backend returns the full appointment data
+      if (result.appointmentData) {
+        console.log(
+          `[APPOINTMENT_SERVICE] Appointment created with ID: ${result.appointmentId}`
+        );
+        return result.appointmentData;
+      }
+
+      // If only the ID is returned, fetch the complete appointment
+      const createdAppointment = await this.getAppointmentById(
+        result.appointmentId
+      );
+      if (!createdAppointment) {
+        throw new Error(
+          `Failed to retrieve created appointment with ID: ${result.appointmentId}`
+        );
+      }
+
+      return createdAppointment;
     } catch (error) {
-      console.error("[APPOINTMENT_SERVICE] Error creating appointment:", error);
+      console.error(
+        "[APPOINTMENT_SERVICE] Error creating appointment via cloud function:",
+        error
+      );
       throw error;
     }
   }
@@ -1008,50 +980,6 @@ export class AppointmentService extends BaseService {
     return this.updateAppointment(appointmentId, updateData);
   }
 
-  /**
-   * Marks pre-procedure requirements as completed.
-   *
-   * @param appointmentId ID of the appointment
-   * @param requirementIds IDs of the requirements to mark as completed
-   * @returns The updated appointment
-   */
-  async completePreRequirements(
-    appointmentId: string,
-    requirementIds: string[]
-  ): Promise<Appointment> {
-    console.log(
-      `[APPOINTMENT_SERVICE] Marking pre-requirements as completed for appointment: ${appointmentId}`
-    );
-
-    const updateData: UpdateAppointmentData = {
-      completedPreRequirements: requirementIds,
-    };
-
-    return this.updateAppointment(appointmentId, updateData);
-  }
-
-  /**
-   * Marks post-procedure requirements as completed.
-   *
-   * @param appointmentId ID of the appointment
-   * @param requirementIds IDs of the requirements to mark as completed
-   * @returns The updated appointment
-   */
-  async completePostRequirements(
-    appointmentId: string,
-    requirementIds: string[]
-  ): Promise<Appointment> {
-    console.log(
-      `[APPOINTMENT_SERVICE] Marking post-requirements as completed for appointment: ${appointmentId}`
-    );
-
-    const updateData: UpdateAppointmentData = {
-      completedPostRequirements: requirementIds,
-    };
-
-    return this.updateAppointment(appointmentId, updateData);
-  }
-
   /**
    * Updates the internal notes of an appointment.
    *
@@ -1073,25 +1001,4 @@ export class AppointmentService extends BaseService {
 
     return this.updateAppointment(appointmentId, updateData);
   }
-
-  /**
-   * Debug helper: Get the current user's ID token for testing purposes
-   * Use this token in Postman with Authorization: Bearer TOKEN
-   */
-  async getDebugToken(): Promise<string | null> {
-    try {
-      const currentUser = this.auth.currentUser;
-      if (!currentUser) {
-        console.log("[APPOINTMENT_SERVICE] No user is signed in");
-        return null;
-      }
-
-      const idToken = await currentUser.getIdToken();
-      console.log("[APPOINTMENT_SERVICE] Debug token:", idToken);
-      return idToken;
-    } catch (error) {
-      console.error("[APPOINTMENT_SERVICE] Error getting debug token:", error);
-      return null;
-    }
-  }
 }

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

@@ -179,6 +179,7 @@ export class ProcedureService extends BaseService {
       technology,
       product,
       blockingConditions: technology.blockingConditions,
+      contraindications: technology.contraindications || [],
       treatmentBenefits: technology.benefits,
       preRequirements: technology.requirements.pre,
       postRequirements: technology.requirements.post,

package/src/types/appointment/index.ts

@@ -178,6 +178,7 @@ export interface Appointment {
   completedPostRequirements?: string[]; // IDs of completed post-requirements
 
   /** NEW: Linked forms (consent, procedure-specific forms, etc.) */
+  linkedFormIds?: string[];
   linkedForms?: LinkedFormInfo[];
   pendingUserFormsIds?: string[]; // Determines if there are any user forms that are pending for this appointment, blocks the appointment from being checked in (only for user forms with isRequired = true)
 
@@ -210,7 +211,6 @@ export interface Appointment {
  * Data needed to create a new Appointment
  */
 export interface CreateAppointmentData {
-  calendarEventId: string;
   clinicBranchId: string;
   practitionerId: string;
   patientId: string;
@@ -250,6 +250,7 @@ export interface UpdateAppointmentData {
   practitionerId?: string; // If practitioner is changed
 
   /** NEW: For updating linked forms - typically managed by dedicated methods */
+  linkedFormIds?: string[] | FieldValue;
   linkedForms?: LinkedFormInfo[] | FieldValue;
 
   /** NEW: For updating media items - typically managed by dedicated methods */

package/src/types/procedure/index.ts

@@ -16,6 +16,7 @@ import { ClinicInfo } from "../profile";
 import { DoctorInfo } from "../clinic";
 import { PRACTITIONERS_COLLECTION } from "../practitioner";
 import { ProcedureReviewInfo } from "../reviews";
+import type { Contraindication } from "../../backoffice/types/static/contraindication.types";
 
 /**
  * Procedure represents a specific medical procedure that can be performed by a practitioner in a clinic
@@ -26,6 +27,8 @@ export interface Procedure {
   id: string;
   /** Name of the procedure */
   name: string;
+  /** Photos of the procedure */
+  photos?: string[];
   /** Detailed description of the procedure */
   description: string;
   /** Family of procedures this belongs to (aesthetics/surgery) */
@@ -50,6 +53,8 @@ export interface Procedure {
   blockingConditions: BlockingCondition[];
   /** Treatment benefits of this procedure */
   treatmentBenefits: TreatmentBenefit[];
+  /** Contraindications of this procedure */
+  contraindications: Contraindication[];
   /** Pre-procedure requirements */
   preRequirements: Requirement[];
   /** Post-procedure requirements */
@@ -93,6 +98,7 @@ export interface CreateProcedureData {
   duration: number;
   practitionerId: string;
   clinicBranchId: string;
+  photos?: string[];
 }
 
 /**
@@ -112,6 +118,7 @@ export interface UpdateProcedureData {
   technologyId?: string;
   productId?: string;
   clinicBranchId?: string;
+  photos?: string[];
 }
 
 /**

package/src/validations/appointment.schema.ts

@@ -138,9 +138,6 @@ export const finalizedDetailsSchema = z.object({
  */
 export const createAppointmentSchema = z
   .object({
-    calendarEventId: z
-      .string()
-      .min(MIN_STRING_LENGTH, "Calendar event ID is required"),
     clinicBranchId: z
       .string()
       .min(MIN_STRING_LENGTH, "Clinic branch ID is required"),
@@ -221,6 +218,7 @@ export const updateAppointmentSchema = z
     completedPostRequirements: z
       .union([z.array(z.string()), z.any()])
       .optional(),
+    linkedFormIds: z.union([z.array(z.string()), z.any()]).optional(),
     pendingUserFormsIds: z.union([z.array(z.string()), z.any()]).optional(),
     appointmentStartTime: z
       .any()

package/src/validations/procedure.schema.ts

@@ -24,6 +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(),
 });
 
 /**
@@ -43,6 +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(),
 });
 
 /**
@@ -55,6 +57,7 @@ export const procedureSchema = createProcedureSchema.extend({
   technology: z.any(), // We'll validate the full technology object separately
   product: z.any(), // We'll validate the full product object separately
   blockingConditions: z.array(z.any()), // We'll validate blocking conditions separately
+  contraindications: z.array(z.any()), // We'll validate contraindications separately
   treatmentBenefits: z.array(z.any()), // We'll validate treatment benefits separately
   preRequirements: z.array(z.any()), // We'll validate requirements separately
   postRequirements: z.array(z.any()), // We'll validate requirements separately