@blackcode_sa/metaestetics-api 1.12.7 → 1.12.10

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

@@ -13,11 +13,12 @@ import {
   limit,
   startAfter,
   getDocs,
-} from "firebase/firestore";
-import { Auth } from "firebase/auth";
-import { FirebaseApp } from "firebase/app";
-import { Functions, getFunctions, httpsCallable } from "firebase/functions";
-import { BaseService } from "../base.service";
+  getCountFromServer,
+} from 'firebase/firestore';
+import { Auth } from 'firebase/auth';
+import { FirebaseApp } from 'firebase/app';
+import { Functions, getFunctions, httpsCallable } from 'firebase/functions';
+import { BaseService } from '../base.service';
 import {
   Appointment,
   AppointmentStatus,
@@ -28,26 +29,26 @@ import {
   PatientReviewInfo,
   type CreateAppointmentHttpData,
   APPOINTMENTS_COLLECTION,
-} from "../../types/appointment";
+} from '../../types/appointment';
 import {
   updateAppointmentSchema,
   searchAppointmentsSchema,
   rescheduleAppointmentSchema,
-} from "../../validations/appointment.schema";
+} from '../../validations/appointment.schema';
 
 // Import other services needed (dependency injection pattern)
-import { CalendarServiceV2 } from "../calendar/calendar.v2.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 { CalendarServiceV2 } from '../calendar/calendar.v2.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 {
   updateAppointmentUtil,
   getAppointmentByIdUtil,
   searchAppointmentsUtil,
-} from "./utils/appointment.utils";
+} from './utils/appointment.utils';
 
 /**
  * Interface for available booking slot
@@ -88,7 +89,7 @@ export class AppointmentService extends BaseService {
     patientService: PatientService,
     practitionerService: PractitionerService,
     clinicService: ClinicService,
-    filledDocumentService: FilledDocumentService
+    filledDocumentService: FilledDocumentService,
   ) {
     super(db, auth, app);
     this.calendarService = calendarService;
@@ -96,7 +97,7 @@ export class AppointmentService extends BaseService {
     this.practitionerService = practitionerService;
     this.clinicService = clinicService;
     this.filledDocumentService = filledDocumentService;
-    this.functions = getFunctions(app, "europe-west6"); // Initialize Firebase Functions with the correct region
+    this.functions = getFunctions(app, 'europe-west6'); // Initialize Firebase Functions with the correct region
   }
 
   /**
@@ -115,36 +116,26 @@ export class AppointmentService extends BaseService {
     practitionerId: string,
     procedureId: string,
     startDate: Date,
-    endDate: Date
+    endDate: Date,
   ): Promise<AvailableSlot[]> {
     try {
       console.log(
-        `[APPOINTMENT_SERVICE] Getting available booking slots via HTTP for clinic: ${clinicId}, practitioner: ${practitionerId}, procedure: ${procedureId}`
+        `[APPOINTMENT_SERVICE] Getting available booking slots via HTTP for clinic: ${clinicId}, practitioner: ${practitionerId}, procedure: ${procedureId}`,
       );
 
       // Validate input parameters
-      if (
-        !clinicId ||
-        !practitionerId ||
-        !procedureId ||
-        !startDate ||
-        !endDate
-      ) {
-        throw new Error(
-          "Missing required parameters for booking slots calculation"
-        );
+      if (!clinicId || !practitionerId || !procedureId || !startDate || !endDate) {
+        throw new Error('Missing required parameters for booking slots calculation');
       }
 
       if (endDate <= startDate) {
-        throw new Error("End date must be after start date");
+        throw new Error('End date must be after start date');
       }
 
       // Check if user is authenticated
       const currentUser = this.auth.currentUser;
       if (!currentUser) {
-        throw new Error(
-          "User must be authenticated to get available booking slots"
-        );
+        throw new Error('User must be authenticated to get available booking slots');
       }
 
       // Construct the function URL for the Express app endpoint
@@ -156,9 +147,7 @@ export class AppointmentService extends BaseService {
       const idToken = await currentUser.getIdToken();
 
       // Log that we're getting a token
-      console.log(
-        `[APPOINTMENT_SERVICE] Got user token, user ID: ${currentUser.uid}`
-      );
+      console.log(`[APPOINTMENT_SERVICE] Got user token, user ID: ${currentUser.uid}`);
 
       // Alternate direct URL (if needed):
       // const functionUrl = `https://getavailablebookingslotshttp-grqala5m6a-oa.a.run.app`;
@@ -174,37 +163,33 @@ export class AppointmentService extends BaseService {
         },
       };
 
-      console.log(
-        `[APPOINTMENT_SERVICE] Making fetch request to ${functionUrl}`
-      );
+      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", // Important for cross-origin requests
-        cache: "no-cache", // Don't cache this request
-        credentials: "omit", // Don't send cookies since we're using token auth
+        method: 'POST',
+        mode: 'cors', // Important for cross-origin requests
+        cache: 'no-cache', // Don't cache this request
+        credentials: 'omit', // Don't send cookies since we're using token auth
         headers: {
-          "Content-Type": "application/json",
+          'Content-Type': 'application/json',
           Authorization: `Bearer ${idToken}`,
         },
-        redirect: "follow",
-        referrerPolicy: "no-referrer",
+        redirect: 'follow',
+        referrerPolicy: 'no-referrer',
         body: JSON.stringify(requestData),
       });
 
       console.log(
-        `[APPOINTMENT_SERVICE] Received response ${response.status}: ${response.statusText}`
+        `[APPOINTMENT_SERVICE] Received response ${response.status}: ${response.statusText}`,
       );
 
       // Check if the request was successful
       if (!response.ok) {
         const errorText = await response.text();
-        console.error(
-          `[APPOINTMENT_SERVICE] Error response details: ${errorText}`
-        );
+        console.error(`[APPOINTMENT_SERVICE] Error response details: ${errorText}`);
         throw new Error(
-          `Failed to get available booking slots: ${response.status} ${response.statusText} - ${errorText}`
+          `Failed to get available booking slots: ${response.status} ${response.statusText} - ${errorText}`,
         );
       }
 
@@ -213,28 +198,19 @@ export class AppointmentService extends BaseService {
       console.log(`[APPOINTMENT_SERVICE] Response parsed successfully`, result);
 
       if (!result.success) {
-        throw new Error(
-          result.error || "Failed to get available booking slots"
-        );
+        throw new Error(result.error || 'Failed to get available booking slots');
       }
 
       // Convert timestamp numbers to Date objects
-      const slots: AvailableSlot[] = result.availableSlots.map(
-        (slot: { start: number }) => ({
-          start: new Date(slot.start),
-        })
-      );
+      const slots: AvailableSlot[] = result.availableSlots.map((slot: { start: number }) => ({
+        start: new Date(slot.start),
+      }));
 
-      console.log(
-        `[APPOINTMENT_SERVICE] Found ${slots.length} available booking slots via HTTP`
-      );
+      console.log(`[APPOINTMENT_SERVICE] Found ${slots.length} available booking slots via HTTP`);
 
       return slots;
     } catch (error) {
-      console.error(
-        "[APPOINTMENT_SERVICE] Error getting available booking slots via HTTP:",
-        error
-      );
+      console.error('[APPOINTMENT_SERVICE] Error getting available booking slots via HTTP:', error);
       throw error;
     }
   }
@@ -245,18 +221,14 @@ export class AppointmentService extends BaseService {
    * @param data - CreateAppointmentData object
    * @returns The created appointment
    */
-  async createAppointmentHttp(
-    data: CreateAppointmentHttpData
-  ): Promise<Appointment> {
+  async createAppointmentHttp(data: CreateAppointmentHttpData): Promise<Appointment> {
     try {
-      console.log(
-        "[APPOINTMENT_SERVICE] Creating appointment via cloud function"
-      );
+      console.log('[APPOINTMENT_SERVICE] Creating appointment via cloud function');
 
       // 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");
+        throw new Error('User must be authenticated to create an appointment');
       }
       const idToken = await currentUser.getIdToken();
 
@@ -277,37 +249,33 @@ export class AppointmentService extends BaseService {
         patientNotes: data?.patientNotes || null,
       };
 
-      console.log(
-        `[APPOINTMENT_SERVICE] Making fetch request to ${functionUrl}`
-      );
+      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",
+        method: 'POST',
+        mode: 'cors',
+        cache: 'no-cache',
+        credentials: 'omit',
         headers: {
-          "Content-Type": "application/json",
+          'Content-Type': 'application/json',
           Authorization: `Bearer ${idToken}`,
         },
-        redirect: "follow",
-        referrerPolicy: "no-referrer",
+        redirect: 'follow',
+        referrerPolicy: 'no-referrer',
         body: JSON.stringify(requestData),
       });
 
       console.log(
-        `[APPOINTMENT_SERVICE] Received response ${response.status}: ${response.statusText}`
+        `[APPOINTMENT_SERVICE] Received response ${response.status}: ${response.statusText}`,
       );
 
       // Check if the request was successful
       if (!response.ok) {
         const errorText = await response.text();
-        console.error(
-          `[APPOINTMENT_SERVICE] Error response details: ${errorText}`
-        );
+        console.error(`[APPOINTMENT_SERVICE] Error response details: ${errorText}`);
         throw new Error(
-          `Failed to create appointment: ${response.status} ${response.statusText} - ${errorText}`
+          `Failed to create appointment: ${response.status} ${response.statusText} - ${errorText}`,
         );
       }
 
@@ -315,33 +283,24 @@ export class AppointmentService extends BaseService {
       const result = await response.json();
 
       if (!result.success) {
-        throw new Error(result.error || "Failed to create appointment");
+        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}`
-        );
+        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
-      );
+      const createdAppointment = await this.getAppointmentById(result.appointmentId);
       if (!createdAppointment) {
-        throw new Error(
-          `Failed to retrieve created appointment with ID: ${result.appointmentId}`
-        );
+        throw new Error(`Failed to retrieve created appointment with ID: ${result.appointmentId}`);
       }
 
       return createdAppointment;
     } catch (error) {
-      console.error(
-        "[APPOINTMENT_SERVICE] Error creating appointment via cloud function:",
-        error
-      );
+      console.error('[APPOINTMENT_SERVICE] Error creating appointment via cloud function:', error);
       throw error;
     }
   }
@@ -354,24 +313,17 @@ export class AppointmentService extends BaseService {
    */
   async getAppointmentById(appointmentId: string): Promise<Appointment | null> {
     try {
-      console.log(
-        `[APPOINTMENT_SERVICE] Getting appointment with ID: ${appointmentId}`
-      );
+      console.log(`[APPOINTMENT_SERVICE] Getting appointment with ID: ${appointmentId}`);
 
       const appointment = await getAppointmentByIdUtil(this.db, appointmentId);
 
       console.log(
-        `[APPOINTMENT_SERVICE] Appointment ${appointmentId} ${
-          appointment ? "found" : "not found"
-        }`
+        `[APPOINTMENT_SERVICE] Appointment ${appointmentId} ${appointment ? 'found' : 'not found'}`,
       );
 
       return appointment;
     } catch (error) {
-      console.error(
-        `[APPOINTMENT_SERVICE] Error getting appointment ${appointmentId}:`,
-        error
-      );
+      console.error(`[APPOINTMENT_SERVICE] Error getting appointment ${appointmentId}:`, error);
       throw error;
     }
   }
@@ -385,33 +337,22 @@ export class AppointmentService extends BaseService {
    */
   async updateAppointment(
     appointmentId: string,
-    data: UpdateAppointmentData
+    data: UpdateAppointmentData,
   ): Promise<Appointment> {
     try {
-      console.log(
-        `[APPOINTMENT_SERVICE] Updating appointment with ID: ${appointmentId}`
-      );
+      console.log(`[APPOINTMENT_SERVICE] Updating appointment with ID: ${appointmentId}`);
 
       // Validate input data
       const validatedData = await updateAppointmentSchema.parseAsync(data);
 
       // Update the appointment using the utility function
-      const updatedAppointment = await updateAppointmentUtil(
-        this.db,
-        appointmentId,
-        validatedData
-      );
+      const updatedAppointment = await updateAppointmentUtil(this.db, appointmentId, validatedData);
 
-      console.log(
-        `[APPOINTMENT_SERVICE] Appointment ${appointmentId} updated successfully`
-      );
+      console.log(`[APPOINTMENT_SERVICE] Appointment ${appointmentId} updated successfully`);
 
       return updatedAppointment;
     } catch (error) {
-      console.error(
-        `[APPOINTMENT_SERVICE] Error updating appointment ${appointmentId}:`,
-        error
-      );
+      console.error(`[APPOINTMENT_SERVICE] Error updating appointment ${appointmentId}:`, error);
       throw error;
     }
   }
@@ -427,10 +368,7 @@ export class AppointmentService extends BaseService {
     lastDoc: DocumentSnapshot | null;
   }> {
     try {
-      console.log(
-        "[APPOINTMENT_SERVICE] Searching appointments with params:",
-        params
-      );
+      console.log('[APPOINTMENT_SERVICE] Searching appointments with params:', params);
 
       // Validate search parameters
       await searchAppointmentsSchema.parseAsync(params);
@@ -438,16 +376,11 @@ export class AppointmentService extends BaseService {
       // Search for appointments using the utility function
       const result = await searchAppointmentsUtil(this.db, params);
 
-      console.log(
-        `[APPOINTMENT_SERVICE] Found ${result.appointments.length} appointments`
-      );
+      console.log(`[APPOINTMENT_SERVICE] Found ${result.appointments.length} appointments`);
 
       return result;
     } catch (error) {
-      console.error(
-        "[APPOINTMENT_SERVICE] Error searching appointments:",
-        error
-      );
+      console.error('[APPOINTMENT_SERVICE] Error searching appointments:', error);
       throw error;
     }
   }
@@ -467,14 +400,12 @@ export class AppointmentService extends BaseService {
       status?: AppointmentStatus | AppointmentStatus[];
       limit?: number;
       startAfter?: DocumentSnapshot;
-    }
+    },
   ): Promise<{
     appointments: Appointment[];
     lastDoc: DocumentSnapshot | null;
   }> {
-    console.log(
-      `[APPOINTMENT_SERVICE] Getting appointments for patient: ${patientId}`
-    );
+    console.log(`[APPOINTMENT_SERVICE] Getting appointments for patient: ${patientId}`);
 
     const searchParams: SearchAppointmentsParams = {
       patientId,
@@ -503,14 +434,12 @@ export class AppointmentService extends BaseService {
       status?: AppointmentStatus | AppointmentStatus[];
       limit?: number;
       startAfter?: DocumentSnapshot;
-    }
+    },
   ): Promise<{
     appointments: Appointment[];
     lastDoc: DocumentSnapshot | null;
   }> {
-    console.log(
-      `[APPOINTMENT_SERVICE] Getting appointments for practitioner: ${practitionerId}`
-    );
+    console.log(`[APPOINTMENT_SERVICE] Getting appointments for practitioner: ${practitionerId}`);
 
     const searchParams: SearchAppointmentsParams = {
       practitionerId,
@@ -540,14 +469,12 @@ export class AppointmentService extends BaseService {
       status?: AppointmentStatus | AppointmentStatus[];
       limit?: number;
       startAfter?: DocumentSnapshot;
-    }
+    },
   ): Promise<{
     appointments: Appointment[];
     lastDoc: DocumentSnapshot | null;
   }> {
-    console.log(
-      `[APPOINTMENT_SERVICE] Getting appointments for clinic: ${clinicBranchId}`
-    );
+    console.log(`[APPOINTMENT_SERVICE] Getting appointments for clinic: ${clinicBranchId}`);
 
     const searchParams: SearchAppointmentsParams = {
       clinicBranchId,
@@ -575,11 +502,11 @@ export class AppointmentService extends BaseService {
     newStatus: AppointmentStatus,
     details?: {
       cancellationReason?: string;
-      canceledBy?: "patient" | "clinic" | "practitioner" | "system";
-    }
+      canceledBy?: 'patient' | 'clinic' | 'practitioner' | 'system';
+    },
   ): Promise<Appointment> {
     console.log(
-      `[APPOINTMENT_SERVICE] Updating status of appointment ${appointmentId} to ${newStatus}`
+      `[APPOINTMENT_SERVICE] Updating status of appointment ${appointmentId} to ${newStatus}`,
     );
     const updateData: UpdateAppointmentData = {
       status: newStatus,
@@ -592,10 +519,10 @@ export class AppointmentService extends BaseService {
       newStatus === AppointmentStatus.CANCELED_PATIENT_RESCHEDULED
     ) {
       if (!details?.cancellationReason) {
-        throw new Error("Cancellation reason is required when canceling.");
+        throw new Error('Cancellation reason is required when canceling.');
       }
       if (!details?.canceledBy) {
-        throw new Error("Canceled by is required when canceling.");
+        throw new Error('Canceled by is required when canceling.');
       }
       updateData.cancellationReason = details.cancellationReason;
       updateData.canceledBy = details.canceledBy;
@@ -617,61 +544,35 @@ export class AppointmentService extends BaseService {
    * Confirms a PENDING appointment by an Admin/Clinic.
    */
   async confirmAppointmentAdmin(appointmentId: string): Promise<Appointment> {
-    console.log(
-      `[APPOINTMENT_SERVICE] Admin confirming appointment: ${appointmentId}`
-    );
+    console.log(`[APPOINTMENT_SERVICE] Admin confirming appointment: ${appointmentId}`);
     const appointment = await this.getAppointmentById(appointmentId);
-    if (!appointment)
-      throw new Error(`Appointment ${appointmentId} not found.`);
+    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.`
-      );
+      throw new Error(`Appointment ${appointmentId} is not in PENDING state to be confirmed.`);
     }
-    return this.updateAppointmentStatus(
-      appointmentId,
-      AppointmentStatus.CONFIRMED
-    );
+    return this.updateAppointmentStatus(appointmentId, AppointmentStatus.CONFIRMED);
   }
 
   /**
    * Cancels an appointment by the User (Patient).
    */
-  async cancelAppointmentUser(
-    appointmentId: string,
-    reason: string
-  ): Promise<Appointment> {
-    console.log(
-      `[APPOINTMENT_SERVICE] User canceling appointment: ${appointmentId}`
-    );
-    return this.updateAppointmentStatus(
-      appointmentId,
-      AppointmentStatus.CANCELED_PATIENT,
-      {
-        cancellationReason: reason,
-        canceledBy: "patient",
-      }
-    );
+  async cancelAppointmentUser(appointmentId: string, reason: string): Promise<Appointment> {
+    console.log(`[APPOINTMENT_SERVICE] User canceling appointment: ${appointmentId}`);
+    return this.updateAppointmentStatus(appointmentId, AppointmentStatus.CANCELED_PATIENT, {
+      cancellationReason: reason,
+      canceledBy: 'patient',
+    });
   }
 
   /**
    * Cancels an appointment by an Admin/Clinic.
    */
-  async cancelAppointmentAdmin(
-    appointmentId: string,
-    reason: string
-  ): Promise<Appointment> {
-    console.log(
-      `[APPOINTMENT_SERVICE] Admin canceling appointment: ${appointmentId}`
-    );
-    return this.updateAppointmentStatus(
-      appointmentId,
-      AppointmentStatus.CANCELED_CLINIC,
-      {
-        cancellationReason: reason,
-        canceledBy: "clinic",
-      }
-    );
+  async cancelAppointmentAdmin(appointmentId: string, reason: string): Promise<Appointment> {
+    console.log(`[APPOINTMENT_SERVICE] Admin canceling appointment: ${appointmentId}`);
+    return this.updateAppointmentStatus(appointmentId, AppointmentStatus.CANCELED_CLINIC, {
+      cancellationReason: reason,
+      canceledBy: 'clinic',
+    });
   }
 
   /**
@@ -683,23 +584,17 @@ export class AppointmentService extends BaseService {
     newStartTime: any; // Accept any type (number, string, Timestamp, etc.)
     newEndTime: any; // Accept any type (number, string, Timestamp, etc.)
   }): Promise<Appointment> {
-    console.log(
-      `[APPOINTMENT_SERVICE] Admin rescheduling appointment: ${params.appointmentId}`
-    );
+    console.log(`[APPOINTMENT_SERVICE] Admin rescheduling appointment: ${params.appointmentId}`);
 
     // Validate input data
-    const validatedParams = await rescheduleAppointmentSchema.parseAsync(
-      params
-    );
+    const validatedParams = await rescheduleAppointmentSchema.parseAsync(params);
 
     // Convert input to Timestamp objects
-    const startTimestamp = this.convertToTimestamp(
-      validatedParams.newStartTime
-    );
+    const startTimestamp = this.convertToTimestamp(validatedParams.newStartTime);
     const endTimestamp = this.convertToTimestamp(validatedParams.newEndTime);
 
     if (endTimestamp.toMillis() <= startTimestamp.toMillis()) {
-      throw new Error("New end time must be after new start time.");
+      throw new Error('New end time must be after new start time.');
     }
 
     const updateData: UpdateAppointmentData = {
@@ -725,17 +620,17 @@ export class AppointmentService extends BaseService {
     });
 
     // If it's already a Timestamp object with methods
-    if (value && typeof value.toMillis === "function") {
+    if (value && typeof value.toMillis === 'function') {
       return value;
     }
 
     // If it's a number (milliseconds since epoch)
-    if (typeof value === "number") {
+    if (typeof value === 'number') {
       return Timestamp.fromMillis(value);
     }
 
     // If it's a string (ISO date string)
-    if (typeof value === "string") {
+    if (typeof value === 'string') {
       return Timestamp.fromDate(new Date(value));
     }
 
@@ -745,44 +640,30 @@ export class AppointmentService extends BaseService {
     }
 
     // If it has _seconds property (serialized Timestamp) - THIS IS WHAT FRONTEND SENDS
-    if (value && typeof value._seconds === "number") {
+    if (value && typeof value._seconds === 'number') {
       return new Timestamp(value._seconds, value._nanoseconds || 0);
     }
 
     // If it has seconds property (serialized Timestamp)
-    if (value && typeof value.seconds === "number") {
+    if (value && typeof value.seconds === 'number') {
       return new Timestamp(value.seconds, value.nanoseconds || 0);
     }
 
-    throw new Error(
-      `Invalid timestamp format: ${typeof value}, value: ${JSON.stringify(
-        value
-      )}`
-    );
+    throw new Error(`Invalid timestamp format: ${typeof value}, value: ${JSON.stringify(value)}`);
   }
 
   /**
    * User confirms a reschedule proposed by the clinic.
    * Status changes from RESCHEDULED_BY_CLINIC to CONFIRMED.
    */
-  async rescheduleAppointmentConfirmUser(
-    appointmentId: string
-  ): Promise<Appointment> {
-    console.log(
-      `[APPOINTMENT_SERVICE] User confirming reschedule for: ${appointmentId}`
-    );
+  async rescheduleAppointmentConfirmUser(appointmentId: string): Promise<Appointment> {
+    console.log(`[APPOINTMENT_SERVICE] User confirming reschedule for: ${appointmentId}`);
     const appointment = await this.getAppointmentById(appointmentId);
-    if (!appointment)
-      throw new Error(`Appointment ${appointmentId} not found.`);
+    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.`
-      );
+      throw new Error(`Appointment ${appointmentId} is not in RESCHEDULED_BY_CLINIC state.`);
     }
-    return this.updateAppointmentStatus(
-      appointmentId,
-      AppointmentStatus.CONFIRMED
-    );
+    return this.updateAppointmentStatus(appointmentId, AppointmentStatus.CONFIRMED);
   }
 
   /**
@@ -791,26 +672,21 @@ export class AppointmentService extends BaseService {
    */
   async rescheduleAppointmentRejectUser(
     appointmentId: string,
-    reason: string
+    reason: string,
   ): Promise<Appointment> {
-    console.log(
-      `[APPOINTMENT_SERVICE] User rejecting reschedule for: ${appointmentId}`
-    );
+    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) 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.`
-      );
+      throw new Error(`Appointment ${appointmentId} is not in RESCHEDULED_BY_CLINIC state.`);
     }
     return this.updateAppointmentStatus(
       appointmentId,
       AppointmentStatus.CANCELED_PATIENT_RESCHEDULED,
       {
         cancellationReason: reason,
-        canceledBy: "patient",
-      }
+        canceledBy: 'patient',
+      },
     );
   }
 
@@ -819,23 +695,15 @@ export class AppointmentService extends BaseService {
    * Requires all pending user forms to be completed.
    */
   async checkInPatientAdmin(appointmentId: string): Promise<Appointment> {
-    console.log(
-      `[APPOINTMENT_SERVICE] Admin checking in patient for: ${appointmentId}`
-    );
+    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) throw new Error(`Appointment ${appointmentId} not found.`);
 
-    if (
-      appointment.pendingUserFormsIds &&
-      appointment.pendingUserFormsIds.length > 0
-    ) {
+    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(
-          ", "
-        )}`
+        } pending required form(s). IDs: ${appointment.pendingUserFormsIds.join(', ')}`,
       );
     }
     if (
@@ -843,30 +711,22 @@ export class AppointmentService extends BaseService {
       appointment.status !== AppointmentStatus.RESCHEDULED_BY_CLINIC
     ) {
       console.warn(
-        `Checking in appointment ${appointmentId} with status ${appointment.status}. Ensure this is intended.`
+        `Checking in appointment ${appointmentId} with status ${appointment.status}. Ensure this is intended.`,
       );
     }
 
-    return this.updateAppointmentStatus(
-      appointmentId,
-      AppointmentStatus.CHECKED_IN
-    );
+    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}`
-    );
+    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) throw new Error(`Appointment ${appointmentId} not found.`);
     if (appointment.status !== AppointmentStatus.CHECKED_IN) {
-      throw new Error(
-        `Appointment ${appointmentId} must be CHECKED_IN to start.`
-      );
+      throw new Error(`Appointment ${appointmentId} must be CHECKED_IN to start.`);
     }
     // Update status and set procedureActualStartTime
     const updateData: UpdateAppointmentData = {
@@ -883,33 +743,24 @@ export class AppointmentService extends BaseService {
   async completeAppointmentDoctor(
     appointmentId: string,
     finalizationNotes: string,
-    actualDurationMinutesInput?: number // Renamed to avoid conflict if we calculate
+    actualDurationMinutesInput?: number, // Renamed to avoid conflict if we calculate
   ): Promise<Appointment> {
-    console.log(
-      `[APPOINTMENT_SERVICE] Doctor completing appointment: ${appointmentId}`
-    );
+    console.log(`[APPOINTMENT_SERVICE] Doctor completing appointment: ${appointmentId}`);
     const currentUser = this.auth.currentUser;
-    if (!currentUser)
-      throw new Error("Authentication required to complete appointment.");
+    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.`);
+    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
-    ) {
+    if (calculatedDurationMinutes === undefined && appointment.procedureActualStartTime) {
       const startTimeMillis = appointment.procedureActualStartTime.toMillis();
       const endTimeMillis = procedureCompletionTime.toMillis();
       if (endTimeMillis > startTimeMillis) {
-        calculatedDurationMinutes = Math.round(
-          (endTimeMillis - startTimeMillis) / 60000
-        );
+        calculatedDurationMinutes = Math.round((endTimeMillis - startTimeMillis) / 60000);
       }
     }
 
@@ -932,25 +783,16 @@ export class AppointmentService extends BaseService {
    * Admin marks an appointment as No-Show.
    */
   async markNoShowAdmin(appointmentId: string): Promise<Appointment> {
-    console.log(
-      `[APPOINTMENT_SERVICE] Admin marking no-show for: ${appointmentId}`
-    );
+    console.log(`[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.");
+    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,
-      {
-        cancellationReason: "Patient did not show up for the appointment.",
-        canceledBy: "clinic",
-      }
-    );
+    return this.updateAppointmentStatus(appointmentId, AppointmentStatus.NO_SHOW, {
+      cancellationReason: 'Patient did not show up for the appointment.',
+      canceledBy: 'clinic',
+    });
   }
 
   /**
@@ -958,13 +800,11 @@ export class AppointmentService extends BaseService {
    */
   async addMediaToAppointment(
     appointmentId: string,
-    mediaItemData: Omit<AppointmentMediaItem, "id" | "uploadedAt">
+    mediaItemData: Omit<AppointmentMediaItem, 'id' | 'uploadedAt'>,
   ): Promise<Appointment> {
-    console.log(
-      `[APPOINTMENT_SERVICE] Adding media to appointment ${appointmentId}`
-    );
+    console.log(`[APPOINTMENT_SERVICE] Adding media to appointment ${appointmentId}`);
     const currentUser = this.auth.currentUser;
-    if (!currentUser) throw new Error("Authentication required.");
+    if (!currentUser) throw new Error('Authentication required.');
 
     const newMediaItem: AppointmentMediaItem = {
       ...mediaItemData,
@@ -985,16 +825,16 @@ export class AppointmentService extends BaseService {
    */
   async removeMediaFromAppointment(
     appointmentId: string,
-    mediaItemId: string
+    mediaItemId: string,
   ): Promise<Appointment> {
     console.log(
-      `[APPOINTMENT_SERVICE] Removing media ${mediaItemId} from 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.");
+      throw new Error('Appointment or media list not found.');
     }
-    const mediaToRemove = appointment.media.find((m) => m.id === mediaItemId);
+    const mediaToRemove = appointment.media.find(m => m.id === mediaItemId);
     if (!mediaToRemove) {
       throw new Error(`Media item ${mediaItemId} not found in appointment.`);
     }
@@ -1011,11 +851,9 @@ export class AppointmentService extends BaseService {
    */
   async addReviewToAppointment(
     appointmentId: string,
-    reviewData: Omit<PatientReviewInfo, "reviewedAt" | "reviewId">
+    reviewData: Omit<PatientReviewInfo, 'reviewedAt' | 'reviewId'>,
   ): Promise<Appointment> {
-    console.log(
-      `[APPOINTMENT_SERVICE] Adding review to appointment ${appointmentId}`
-    );
+    console.log(`[APPOINTMENT_SERVICE] Adding review to appointment ${appointmentId}`);
     const newReviewInfo: PatientReviewInfo = {
       ...reviewData,
       reviewId: this.generateId(),
@@ -1034,10 +872,10 @@ export class AppointmentService extends BaseService {
   async updatePaymentStatus(
     appointmentId: string,
     paymentStatus: PaymentStatus,
-    paymentTransactionId?: string
+    paymentTransactionId?: string,
   ): Promise<Appointment> {
     console.log(
-      `[APPOINTMENT_SERVICE] Updating payment status of appointment ${appointmentId} to ${paymentStatus}`
+      `[APPOINTMENT_SERVICE] Updating payment status of appointment ${appointmentId} to ${paymentStatus}`,
     );
     const updateData: UpdateAppointmentData = {
       paymentStatus,
@@ -1054,13 +892,8 @@ export class AppointmentService extends BaseService {
    * @param notes Updated internal notes
    * @returns The updated appointment
    */
-  async updateInternalNotes(
-    appointmentId: string,
-    notes: string | null
-  ): Promise<Appointment> {
-    console.log(
-      `[APPOINTMENT_SERVICE] Updating internal notes for appointment: ${appointmentId}`
-    );
+  async updateInternalNotes(appointmentId: string, notes: string | null): Promise<Appointment> {
+    console.log(`[APPOINTMENT_SERVICE] Updating internal notes for appointment: ${appointmentId}`);
 
     const updateData: UpdateAppointmentData = {
       internalNotes: notes,
@@ -1084,15 +917,13 @@ export class AppointmentService extends BaseService {
       endDate?: Date;
       limit?: number;
       startAfter?: DocumentSnapshot;
-    }
+    },
   ): Promise<{
     appointments: Appointment[];
     lastDoc: DocumentSnapshot | null;
   }> {
     try {
-      console.log(
-        `[APPOINTMENT_SERVICE] Getting upcoming appointments for patient: ${patientId}`
-      );
+      console.log(`[APPOINTMENT_SERVICE] Getting upcoming appointments for patient: ${patientId}`);
 
       // Default to current date/time if no startDate provided
       const effectiveStartDate = options?.startDate || new Date();
@@ -1110,32 +941,20 @@ export class AppointmentService extends BaseService {
       const constraints: QueryConstraint[] = [];
 
       // Patient ID filter
-      constraints.push(where("patientId", "==", patientId));
+      constraints.push(where('patientId', '==', patientId));
 
       // Status filter - multiple statuses
-      constraints.push(where("status", "in", upcomingStatuses));
+      constraints.push(where('status', 'in', upcomingStatuses));
 
       // Date range filters
-      constraints.push(
-        where(
-          "appointmentStartTime",
-          ">=",
-          Timestamp.fromDate(effectiveStartDate)
-        )
-      );
+      constraints.push(where('appointmentStartTime', '>=', Timestamp.fromDate(effectiveStartDate)));
 
       if (options?.endDate) {
-        constraints.push(
-          where(
-            "appointmentStartTime",
-            "<=",
-            Timestamp.fromDate(options.endDate)
-          )
-        );
+        constraints.push(where('appointmentStartTime', '<=', Timestamp.fromDate(options.endDate)));
       }
 
       // Order by appointment start time (ascending for upcoming - closest first)
-      constraints.push(orderBy("appointmentStartTime", "asc"));
+      constraints.push(orderBy('appointmentStartTime', 'asc'));
 
       // Add pagination if specified
       if (options?.limit) {
@@ -1147,32 +966,25 @@ export class AppointmentService extends BaseService {
       }
 
       // Execute query
-      const q = query(
-        collection(this.db, APPOINTMENTS_COLLECTION),
-        ...constraints
-      );
+      const q = query(collection(this.db, APPOINTMENTS_COLLECTION), ...constraints);
       const querySnapshot = await getDocs(q);
 
       // Extract results
-      const appointments = querySnapshot.docs.map(
-        (doc) => doc.data() as Appointment
-      );
+      const appointments = querySnapshot.docs.map(doc => doc.data() as Appointment);
 
       // Get last document for pagination
       const lastDoc =
-        querySnapshot.docs.length > 0
-          ? querySnapshot.docs[querySnapshot.docs.length - 1]
-          : null;
+        querySnapshot.docs.length > 0 ? querySnapshot.docs[querySnapshot.docs.length - 1] : null;
 
       console.log(
-        `[APPOINTMENT_SERVICE] Found ${appointments.length} upcoming appointments for patient ${patientId}`
+        `[APPOINTMENT_SERVICE] Found ${appointments.length} upcoming appointments for patient ${patientId}`,
       );
 
       return { appointments, lastDoc };
     } catch (error) {
       console.error(
         `[APPOINTMENT_SERVICE] Error getting upcoming appointments for patient ${patientId}:`,
-        error
+        error,
       );
       throw error;
     }
@@ -1196,15 +1008,13 @@ export class AppointmentService extends BaseService {
       showNoShow?: boolean; // Whether to include no-show appointments
       limit?: number;
       startAfter?: DocumentSnapshot;
-    }
+    },
   ): Promise<{
     appointments: Appointment[];
     lastDoc: DocumentSnapshot | null;
   }> {
     try {
-      console.log(
-        `[APPOINTMENT_SERVICE] Getting past appointments for patient: ${patientId}`
-      );
+      console.log(`[APPOINTMENT_SERVICE] Getting past appointments for patient: ${patientId}`);
 
       // Default to current date/time if no endDate provided
       const effectiveEndDate = options?.endDate || new Date();
@@ -1217,7 +1027,7 @@ export class AppointmentService extends BaseService {
         pastStatuses.push(
           AppointmentStatus.CANCELED_PATIENT,
           AppointmentStatus.CANCELED_PATIENT_RESCHEDULED,
-          AppointmentStatus.CANCELED_CLINIC
+          AppointmentStatus.CANCELED_CLINIC,
         );
       }
 
@@ -1230,32 +1040,22 @@ export class AppointmentService extends BaseService {
       const constraints: QueryConstraint[] = [];
 
       // Patient ID filter
-      constraints.push(where("patientId", "==", patientId));
+      constraints.push(where('patientId', '==', patientId));
 
       // Status filter - multiple statuses
-      constraints.push(where("status", "in", pastStatuses));
+      constraints.push(where('status', 'in', pastStatuses));
 
       // Date range filters
       if (options?.startDate) {
         constraints.push(
-          where(
-            "appointmentStartTime",
-            ">=",
-            Timestamp.fromDate(options.startDate)
-          )
+          where('appointmentStartTime', '>=', Timestamp.fromDate(options.startDate)),
         );
       }
 
-      constraints.push(
-        where(
-          "appointmentStartTime",
-          "<=",
-          Timestamp.fromDate(effectiveEndDate)
-        )
-      );
+      constraints.push(where('appointmentStartTime', '<=', Timestamp.fromDate(effectiveEndDate)));
 
       // Order by appointment start time (descending for past - most recent first)
-      constraints.push(orderBy("appointmentStartTime", "desc"));
+      constraints.push(orderBy('appointmentStartTime', 'desc'));
 
       // Add pagination if specified
       if (options?.limit) {
@@ -1267,32 +1067,79 @@ export class AppointmentService extends BaseService {
       }
 
       // Execute query
-      const q = query(
-        collection(this.db, APPOINTMENTS_COLLECTION),
-        ...constraints
-      );
+      const q = query(collection(this.db, APPOINTMENTS_COLLECTION), ...constraints);
       const querySnapshot = await getDocs(q);
 
       // Extract results
-      const appointments = querySnapshot.docs.map(
-        (doc) => doc.data() as Appointment
-      );
+      const appointments = querySnapshot.docs.map(doc => doc.data() as Appointment);
 
       // Get last document for pagination
       const lastDoc =
-        querySnapshot.docs.length > 0
-          ? querySnapshot.docs[querySnapshot.docs.length - 1]
-          : null;
+        querySnapshot.docs.length > 0 ? querySnapshot.docs[querySnapshot.docs.length - 1] : null;
 
       console.log(
-        `[APPOINTMENT_SERVICE] Found ${appointments.length} past appointments for patient ${patientId}`
+        `[APPOINTMENT_SERVICE] Found ${appointments.length} past appointments for patient ${patientId}`,
       );
 
       return { appointments, lastDoc };
     } catch (error) {
       console.error(
         `[APPOINTMENT_SERVICE] Error getting past appointments for patient ${patientId}:`,
-        error
+        error,
+      );
+      throw error;
+    }
+  }
+
+  /**
+   * Counts completed appointments for a patient with optional clinic filtering.
+   *
+   * @param patientId ID of the patient.
+   * @param clinicBranchId Optional ID of the clinic branch to either include or exclude.
+   * @param excludeClinic Optional boolean. If true (default), excludes the specified clinic. If false, includes only that clinic.
+   * @returns The count of completed appointments.
+   */
+  async countCompletedAppointments(
+    patientId: string,
+    clinicBranchId?: string,
+    excludeClinic = true,
+  ): Promise<number> {
+    try {
+      console.log(
+        `[APPOINTMENT_SERVICE] Counting completed appointments for patient: ${patientId}`,
+        { clinicBranchId, excludeClinic },
+      );
+
+      // Build query constraints
+      const constraints: QueryConstraint[] = [
+        where('patientId', '==', patientId),
+        where('status', '==', AppointmentStatus.COMPLETED),
+      ];
+
+      if (clinicBranchId) {
+        if (excludeClinic) {
+          // Exclude appointments from the specified clinic
+          constraints.push(where('clinicBranchId', '!=', clinicBranchId));
+        } else {
+          // Include only appointments from the specified clinic
+          constraints.push(where('clinicBranchId', '==', clinicBranchId));
+        }
+      }
+
+      // Execute query to get only the count
+      const q = query(collection(this.db, APPOINTMENTS_COLLECTION), ...constraints);
+      const snapshot = await getCountFromServer(q);
+      const count = snapshot.data().count;
+
+      console.log(
+        `[APPOINTMENT_SERVICE] Found ${count} completed appointments for patient ${patientId}`,
+      );
+
+      return count;
+    } catch (error) {
+      console.error(
+        `[APPOINTMENT_SERVICE] Error counting completed appointments for patient ${patientId}:`,
+        error,
       );
       throw error;
     }