@blackcode_sa/metaestetics-api 1.6.3 → 1.6.5

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

@@ -3,6 +3,8 @@ import {
   Timestamp,
   DocumentSnapshot,
   serverTimestamp,
+  arrayUnion,
+  arrayRemove,
 } from "firebase/firestore";
 import { Auth } from "firebase/auth";
 import { FirebaseApp } from "firebase/app";
@@ -15,6 +17,9 @@ import {
   UpdateAppointmentData,
   SearchAppointmentsParams,
   PaymentStatus,
+  AppointmentMediaItem,
+  PatientReviewInfo,
+  LinkedFormInfo,
 } from "../../types/appointment";
 import {
   createAppointmentSchema,
@@ -27,6 +32,7 @@ import { CalendarServiceV2 } from "../calendar/calendar-refactored.service";
 import { PatientService } from "../patient/patient.service";
 import { PractitionerService } from "../practitioner/practitioner.service";
 import { ClinicService } from "../clinic/clinic.service";
+import { FilledDocumentService } from "../documentation-templates/filled-document.service";
 
 // Import utility functions
 import {
@@ -54,6 +60,7 @@ export class AppointmentService extends BaseService {
   private patientService: PatientService;
   private practitionerService: PractitionerService;
   private clinicService: ClinicService;
+  private filledDocumentService: FilledDocumentService;
   private functions: Functions;
 
   /**
@@ -74,110 +81,18 @@ export class AppointmentService extends BaseService {
     calendarService: CalendarServiceV2,
     patientService: PatientService,
     practitionerService: PractitionerService,
-    clinicService: ClinicService
+    clinicService: ClinicService,
+    filledDocumentService: FilledDocumentService
   ) {
     super(db, auth, app);
     this.calendarService = calendarService;
     this.patientService = patientService;
     this.practitionerService = practitionerService;
     this.clinicService = clinicService;
+    this.filledDocumentService = filledDocumentService;
     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.
@@ -319,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;
     }
   }
@@ -580,61 +561,67 @@ export class AppointmentService extends BaseService {
    *
    * @param appointmentId ID of the appointment
    * @param newStatus New status to set
-   * @param cancellationReason Required if canceling the appointment
-   * @param canceledBy Required if canceling the appointment
+   * @param details Optional details for the status change
    * @returns The updated appointment
    */
   async updateAppointmentStatus(
     appointmentId: string,
     newStatus: AppointmentStatus,
-    cancellationReason?: string,
-    canceledBy?: "patient" | "clinic" | "practitioner" | "system"
+    details?: {
+      cancellationReason?: string;
+      canceledBy?: "patient" | "clinic" | "practitioner" | "system";
+    }
   ): Promise<Appointment> {
     console.log(
       `[APPOINTMENT_SERVICE] Updating status of appointment ${appointmentId} to ${newStatus}`
     );
+    const updateData: UpdateAppointmentData = {
+      status: newStatus,
+      updatedAt: serverTimestamp(),
+    };
 
-    // Create update data based on the new status
-    const updateData: UpdateAppointmentData = { status: newStatus };
-
-    // Add cancellation details if applicable
     if (
       newStatus === AppointmentStatus.CANCELED_CLINIC ||
-      newStatus === AppointmentStatus.CANCELED_PATIENT
+      newStatus === AppointmentStatus.CANCELED_PATIENT ||
+      newStatus === AppointmentStatus.CANCELED_PATIENT_RESCHEDULED
     ) {
-      if (!cancellationReason) {
-        throw new Error(
-          "Cancellation reason is required when canceling an appointment"
-        );
+      if (!details?.cancellationReason) {
+        throw new Error("Cancellation reason is required when canceling.");
       }
-      if (!canceledBy) {
-        throw new Error(
-          "Canceled by is required when canceling an appointment"
-        );
+      if (!details?.canceledBy) {
+        throw new Error("Canceled by is required when canceling.");
       }
-
-      updateData.cancellationReason = cancellationReason;
-      updateData.canceledBy = canceledBy;
+      updateData.cancellationReason = details.cancellationReason;
+      updateData.canceledBy = details.canceledBy;
+      updateData.cancellationTime = Timestamp.now();
     }
 
-    // Add confirmation time if confirming
     if (newStatus === AppointmentStatus.CONFIRMED) {
       updateData.confirmationTime = Timestamp.now();
     }
 
+    if (newStatus === AppointmentStatus.RESCHEDULED_BY_CLINIC) {
+      updateData.rescheduleTime = Timestamp.now();
+    }
+
     return this.updateAppointment(appointmentId, updateData);
   }
 
   /**
-   * Confirms an appointment.
-   *
-   * @param appointmentId ID of the appointment to confirm
-   * @returns The confirmed appointment
+   * Confirms a PENDING appointment by an Admin/Clinic.
    */
-  async confirmAppointment(appointmentId: string): Promise<Appointment> {
+  async confirmAppointmentAdmin(appointmentId: string): Promise<Appointment> {
     console.log(
-      `[APPOINTMENT_SERVICE] Confirming appointment: ${appointmentId}`
+      `[APPOINTMENT_SERVICE] Admin confirming appointment: ${appointmentId}`
     );
+    const appointment = await this.getAppointmentById(appointmentId);
+    if (!appointment)
+      throw new Error(`Appointment ${appointmentId} not found.`);
+    if (appointment.status !== AppointmentStatus.PENDING) {
+      throw new Error(
+        `Appointment ${appointmentId} is not in PENDING state to be confirmed.`
+      );
+    }
     return this.updateAppointmentStatus(
       appointmentId,
       AppointmentStatus.CONFIRMED
@@ -642,184 +629,354 @@ export class AppointmentService extends BaseService {
   }
 
   /**
-   * Cancels an appointment from the clinic side.
-   *
-   * @param appointmentId ID of the appointment to cancel
-   * @param reason Reason for cancellation
-   * @returns The canceled appointment
+   * Cancels an appointment by the User (Patient).
    */
-  async cancelAppointmentByClinic(
+  async cancelAppointmentUser(
     appointmentId: string,
     reason: string
   ): Promise<Appointment> {
     console.log(
-      `[APPOINTMENT_SERVICE] Canceling appointment by clinic: ${appointmentId}`
+      `[APPOINTMENT_SERVICE] User canceling appointment: ${appointmentId}`
     );
     return this.updateAppointmentStatus(
       appointmentId,
-      AppointmentStatus.CANCELED_CLINIC,
-      reason,
-      "clinic"
+      AppointmentStatus.CANCELED_PATIENT,
+      {
+        cancellationReason: reason,
+        canceledBy: "patient",
+      }
     );
   }
 
   /**
-   * Cancels an appointment from the patient side.
-   *
-   * @param appointmentId ID of the appointment to cancel
-   * @param reason Reason for cancellation
-   * @returns The canceled appointment
+   * Cancels an appointment by an Admin/Clinic.
    */
-  async cancelAppointmentByPatient(
+  async cancelAppointmentAdmin(
     appointmentId: string,
     reason: string
   ): Promise<Appointment> {
     console.log(
-      `[APPOINTMENT_SERVICE] Canceling appointment by patient: ${appointmentId}`
+      `[APPOINTMENT_SERVICE] Admin canceling appointment: ${appointmentId}`
     );
     return this.updateAppointmentStatus(
       appointmentId,
-      AppointmentStatus.CANCELED_PATIENT,
-      reason,
-      "patient"
+      AppointmentStatus.CANCELED_CLINIC,
+      {
+        cancellationReason: reason,
+        canceledBy: "clinic",
+      }
     );
   }
 
   /**
-   * Marks an appointment as checked in.
-   *
-   * @param appointmentId ID of the appointment
-   * @returns The updated appointment
+   * Admin proposes to reschedule an appointment.
+   * Sets status to RESCHEDULED_BY_CLINIC and updates times.
+   */
+  async rescheduleAppointmentAdmin(
+    appointmentId: string,
+    newStartTime: Timestamp,
+    newEndTime: Timestamp
+  ): Promise<Appointment> {
+    console.log(
+      `[APPOINTMENT_SERVICE] Admin rescheduling appointment: ${appointmentId}`
+    );
+    if (newEndTime.toMillis() <= newStartTime.toMillis()) {
+      throw new Error("New end time must be after new start time.");
+    }
+    const updateData: UpdateAppointmentData = {
+      status: AppointmentStatus.RESCHEDULED_BY_CLINIC,
+      appointmentStartTime: newStartTime,
+      appointmentEndTime: newEndTime,
+      rescheduleTime: Timestamp.now(),
+      confirmationTime: null,
+      updatedAt: serverTimestamp(),
+    };
+    return this.updateAppointment(appointmentId, updateData);
+  }
+
+  /**
+   * User confirms a reschedule proposed by the clinic.
+   * Status changes from RESCHEDULED_BY_CLINIC to CONFIRMED.
    */
-  async checkInAppointment(appointmentId: string): Promise<Appointment> {
+  async rescheduleAppointmentConfirmUser(
+    appointmentId: string
+  ): Promise<Appointment> {
     console.log(
-      `[APPOINTMENT_SERVICE] Checking in appointment: ${appointmentId}`
+      `[APPOINTMENT_SERVICE] User confirming reschedule for: ${appointmentId}`
     );
+    const appointment = await this.getAppointmentById(appointmentId);
+    if (!appointment)
+      throw new Error(`Appointment ${appointmentId} not found.`);
+    if (appointment.status !== AppointmentStatus.RESCHEDULED_BY_CLINIC) {
+      throw new Error(
+        `Appointment ${appointmentId} is not in RESCHEDULED_BY_CLINIC state.`
+      );
+    }
     return this.updateAppointmentStatus(
       appointmentId,
-      AppointmentStatus.CHECKED_IN
+      AppointmentStatus.CONFIRMED
     );
   }
 
   /**
-   * Marks an appointment as in progress.
-   *
-   * @param appointmentId ID of the appointment
-   * @returns The updated appointment
+   * User rejects a reschedule proposed by the clinic.
+   * Status changes from RESCHEDULED_BY_CLINIC to CANCELED_PATIENT_RESCHEDULED.
    */
-  async startAppointment(appointmentId: string): Promise<Appointment> {
-    console.log(`[APPOINTMENT_SERVICE] Starting appointment: ${appointmentId}`);
+  async rescheduleAppointmentRejectUser(
+    appointmentId: string,
+    reason: string
+  ): Promise<Appointment> {
+    console.log(
+      `[APPOINTMENT_SERVICE] User rejecting reschedule for: ${appointmentId}`
+    );
+    const appointment = await this.getAppointmentById(appointmentId);
+    if (!appointment)
+      throw new Error(`Appointment ${appointmentId} not found.`);
+    if (appointment.status !== AppointmentStatus.RESCHEDULED_BY_CLINIC) {
+      throw new Error(
+        `Appointment ${appointmentId} is not in RESCHEDULED_BY_CLINIC state.`
+      );
+    }
     return this.updateAppointmentStatus(
       appointmentId,
-      AppointmentStatus.IN_PROGRESS
+      AppointmentStatus.CANCELED_PATIENT_RESCHEDULED,
+      {
+        cancellationReason: reason,
+        canceledBy: "patient",
+      }
     );
   }
 
   /**
-   * Marks an appointment as completed.
-   *
-   * @param appointmentId ID of the appointment
-   * @param actualDurationMinutes Actual duration of the appointment in minutes
-   * @returns The updated appointment
+   * Admin checks in a patient for their appointment.
+   * Requires all pending user forms to be completed.
    */
-  async completeAppointment(
+  async checkInPatientAdmin(appointmentId: string): Promise<Appointment> {
+    console.log(
+      `[APPOINTMENT_SERVICE] Admin checking in patient for: ${appointmentId}`
+    );
+    const appointment = await this.getAppointmentById(appointmentId);
+    if (!appointment)
+      throw new Error(`Appointment ${appointmentId} not found.`);
+
+    if (
+      appointment.pendingUserFormsIds &&
+      appointment.pendingUserFormsIds.length > 0
+    ) {
+      throw new Error(
+        `Cannot check in: Patient has ${
+          appointment.pendingUserFormsIds.length
+        } pending required form(s). IDs: ${appointment.pendingUserFormsIds.join(
+          ", "
+        )}`
+      );
+    }
+    if (
+      appointment.status !== AppointmentStatus.CONFIRMED &&
+      appointment.status !== AppointmentStatus.RESCHEDULED_BY_CLINIC
+    ) {
+      console.warn(
+        `Checking in appointment ${appointmentId} with status ${appointment.status}. Ensure this is intended.`
+      );
+    }
+
+    return this.updateAppointmentStatus(
+      appointmentId,
+      AppointmentStatus.CHECKED_IN
+    );
+  }
+
+  /**
+   * Doctor starts the appointment procedure.
+   */
+  async startAppointmentDoctor(appointmentId: string): Promise<Appointment> {
+    console.log(
+      `[APPOINTMENT_SERVICE] Doctor starting appointment: ${appointmentId}`
+    );
+    const appointment = await this.getAppointmentById(appointmentId);
+    if (!appointment)
+      throw new Error(`Appointment ${appointmentId} not found.`);
+    if (appointment.status !== AppointmentStatus.CHECKED_IN) {
+      throw new Error(
+        `Appointment ${appointmentId} must be CHECKED_IN to start.`
+      );
+    }
+    // Update status and set procedureActualStartTime
+    const updateData: UpdateAppointmentData = {
+      status: AppointmentStatus.IN_PROGRESS,
+      procedureActualStartTime: Timestamp.now(), // Set actual start time
+      updatedAt: serverTimestamp(),
+    };
+    return this.updateAppointment(appointmentId, updateData);
+  }
+
+  /**
+   * Doctor completes and finalizes the appointment.
+   */
+  async completeAppointmentDoctor(
     appointmentId: string,
-    actualDurationMinutes?: number
+    finalizationNotes: string,
+    actualDurationMinutesInput?: number // Renamed to avoid conflict if we calculate
   ): Promise<Appointment> {
     console.log(
-      `[APPOINTMENT_SERVICE] Completing appointment: ${appointmentId}`
+      `[APPOINTMENT_SERVICE] Doctor completing appointment: ${appointmentId}`
     );
+    const currentUser = this.auth.currentUser;
+    if (!currentUser)
+      throw new Error("Authentication required to complete appointment.");
+
+    const appointment = await this.getAppointmentById(appointmentId);
+    if (!appointment)
+      throw new Error(`Appointment ${appointmentId} not found.`);
+
+    let calculatedDurationMinutes = actualDurationMinutesInput;
+    const procedureCompletionTime = Timestamp.now();
+
+    // Calculate duration if not provided and actual start time is available
+    if (
+      calculatedDurationMinutes === undefined &&
+      appointment.procedureActualStartTime
+    ) {
+      const startTimeMillis = appointment.procedureActualStartTime.toMillis();
+      const endTimeMillis = procedureCompletionTime.toMillis();
+      if (endTimeMillis > startTimeMillis) {
+        calculatedDurationMinutes = Math.round(
+          (endTimeMillis - startTimeMillis) / 60000
+        );
+      }
+    }
 
     const updateData: UpdateAppointmentData = {
       status: AppointmentStatus.COMPLETED,
-      actualDurationMinutes,
+      actualDurationMinutes: calculatedDurationMinutes, // Use calculated or provided duration
+      finalizedDetails: {
+        by: currentUser.uid, // This is used ID, not practitioner's profile ID (just so we know who completed the appointment)
+        at: procedureCompletionTime, // Use consistent completion timestamp
+        notes: finalizationNotes,
+      },
+      // Optionally update appointmentEndTime to the actual completion time
+      // appointmentEndTime: procedureCompletionTime,
+      updatedAt: serverTimestamp(),
     };
-
     return this.updateAppointment(appointmentId, updateData);
   }
 
   /**
-   * Marks an appointment as no-show.
-   *
-   * @param appointmentId ID of the appointment
-   * @returns The updated appointment
+   * Admin marks an appointment as No-Show.
    */
-  async markNoShow(appointmentId: string): Promise<Appointment> {
+  async markNoShowAdmin(appointmentId: string): Promise<Appointment> {
     console.log(
-      `[APPOINTMENT_SERVICE] Marking appointment as no-show: ${appointmentId}`
+      `[APPOINTMENT_SERVICE] Admin marking no-show for: ${appointmentId}`
     );
+    const appointment = await this.getAppointmentById(appointmentId);
+    if (!appointment)
+      throw new Error(`Appointment ${appointmentId} not found.`);
+    if (
+      Timestamp.now().toMillis() < appointment.appointmentStartTime.toMillis()
+    ) {
+      throw new Error("Cannot mark no-show before appointment start time.");
+    }
     return this.updateAppointmentStatus(
       appointmentId,
-      AppointmentStatus.NO_SHOW
+      AppointmentStatus.NO_SHOW,
+      {
+        cancellationReason: "Patient did not show up for the appointment.",
+        canceledBy: "clinic",
+      }
     );
   }
 
   /**
-   * Updates the payment status of an appointment.
-   *
-   * @param appointmentId ID of the appointment
-   * @param paymentStatus New payment status
-   * @param paymentTransactionId Optional transaction ID for the payment
-   * @returns The updated appointment
+   * Adds a media item to an appointment.
    */
-  async updatePaymentStatus(
+  async addMediaToAppointment(
     appointmentId: string,
-    paymentStatus: PaymentStatus,
-    paymentTransactionId?: string
+    mediaItemData: Omit<AppointmentMediaItem, "id" | "uploadedAt">
   ): Promise<Appointment> {
     console.log(
-      `[APPOINTMENT_SERVICE] Updating payment status of appointment ${appointmentId} to ${paymentStatus}`
+      `[APPOINTMENT_SERVICE] Adding media to appointment ${appointmentId}`
     );
+    const currentUser = this.auth.currentUser;
+    if (!currentUser) throw new Error("Authentication required.");
+
+    const newMediaItem: AppointmentMediaItem = {
+      ...mediaItemData,
+      id: this.generateId(),
+      uploadedAt: Timestamp.now(),
+      uploadedBy: currentUser.uid,
+    };
 
     const updateData: UpdateAppointmentData = {
-      paymentStatus,
-      paymentTransactionId: paymentTransactionId || null,
+      media: arrayUnion(newMediaItem) as any,
+      updatedAt: serverTimestamp(),
     };
-
     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
+   * Removes a media item from an appointment.
    */
-  async completePreRequirements(
+  async removeMediaFromAppointment(
     appointmentId: string,
-    requirementIds: string[]
+    mediaItemId: string
   ): Promise<Appointment> {
     console.log(
-      `[APPOINTMENT_SERVICE] Marking pre-requirements as completed for appointment: ${appointmentId}`
+      `[APPOINTMENT_SERVICE] Removing media ${mediaItemId} from appointment ${appointmentId}`
     );
+    const appointment = await this.getAppointmentById(appointmentId);
+    if (!appointment || !appointment.media) {
+      throw new Error("Appointment or media list not found.");
+    }
+    const mediaToRemove = appointment.media.find((m) => m.id === mediaItemId);
+    if (!mediaToRemove) {
+      throw new Error(`Media item ${mediaItemId} not found in appointment.`);
+    }
 
     const updateData: UpdateAppointmentData = {
-      completedPreRequirements: requirementIds,
+      media: arrayRemove(mediaToRemove) as any,
+      updatedAt: serverTimestamp(),
     };
-
     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
+   * Adds or updates review information for an appointment.
    */
-  async completePostRequirements(
+  async addReviewToAppointment(
     appointmentId: string,
-    requirementIds: string[]
+    reviewData: Omit<PatientReviewInfo, "reviewedAt" | "reviewId">
   ): Promise<Appointment> {
     console.log(
-      `[APPOINTMENT_SERVICE] Marking post-requirements as completed for appointment: ${appointmentId}`
+      `[APPOINTMENT_SERVICE] Adding review to appointment ${appointmentId}`
     );
-
+    const newReviewInfo: PatientReviewInfo = {
+      ...reviewData,
+      reviewId: this.generateId(),
+      reviewedAt: Timestamp.now(),
+    };
     const updateData: UpdateAppointmentData = {
-      completedPostRequirements: requirementIds,
+      reviewInfo: newReviewInfo,
+      updatedAt: serverTimestamp(),
     };
+    return this.updateAppointment(appointmentId, updateData);
+  }
 
+  /**
+   * Updates the payment status of an appointment.
+   */
+  async updatePaymentStatus(
+    appointmentId: string,
+    paymentStatus: PaymentStatus,
+    paymentTransactionId?: string
+  ): Promise<Appointment> {
+    console.log(
+      `[APPOINTMENT_SERVICE] Updating payment status of appointment ${appointmentId} to ${paymentStatus}`
+    );
+    const updateData: UpdateAppointmentData = {
+      paymentStatus,
+      paymentTransactionId: paymentTransactionId || null,
+      updatedAt: serverTimestamp(),
+    };
     return this.updateAppointment(appointmentId, updateData);
   }
 
@@ -844,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;
-    }
-  }
 }