@blackcode_sa/metaestetics-api 1.12.61 → 1.12.62

package/src/services/calendar/calendar.service.ts

@@ -1,1077 +1,1077 @@
-import { Auth } from "firebase/auth";
-import { Firestore, Timestamp } from "firebase/firestore";
-import { FirebaseApp } from "firebase/app";
-import { BaseService } from "../base.service";
-import {
-  CalendarEvent,
-  CalendarEventStatus,
-  CalendarEventTime,
-  CalendarEventType,
-  CalendarSyncStatus,
-  CreateCalendarEventData,
-  UpdateCalendarEventData,
-  CALENDAR_COLLECTION,
-  SyncedCalendarEvent,
-} from "../../types/calendar";
-import { PRACTITIONERS_COLLECTION } from "../../types/practitioner";
-import { PATIENTS_COLLECTION } from "../../types/patient";
-import { CLINICS_COLLECTION } from "../../types/clinic";
-import { SyncedCalendarProvider } from "../../types/calendar/synced-calendar.types";
-
-// Import utility functions from the index file
-import {
-  createPractitionerCalendarEventUtil,
-  createPatientCalendarEventUtil,
-  createClinicCalendarEventUtil,
-  getPractitionerCalendarEventUtil,
-  getPatientCalendarEventUtil,
-  getClinicCalendarEventUtil,
-  getPractitionerCalendarEventsUtil,
-  getPatientCalendarEventsUtil,
-  getClinicCalendarEventsUtil,
-  updatePractitionerCalendarEventUtil,
-  updatePatientCalendarEventUtil,
-  updateClinicCalendarEventUtil,
-  deletePractitionerCalendarEventUtil,
-  deletePatientCalendarEventUtil,
-  deleteClinicCalendarEventUtil,
-} from "./utils";
-
-// Import the SyncedCalendarsService for calendar synchronization
-import { SyncedCalendarsService } from "./synced-calendars.service";
-
-/**
- * Service for managing calendar events
- */
-export class CalendarService extends BaseService {
-  private syncedCalendarsService: SyncedCalendarsService;
-
-  /**
-   * Creates a new CalendarService instance
-   * @param db - Firestore instance
-   * @param auth - Firebase Auth instance
-   * @param app - Firebase App instance
-   */
-  constructor(db: Firestore, auth: Auth, app: FirebaseApp) {
-    super(db, auth, app);
-    this.syncedCalendarsService = new SyncedCalendarsService(db, auth, app);
-  }
-
-  /**
-   * Creates a calendar event for a practitioner
-   * @param practitionerId - ID of the practitioner
-   * @param eventData - Calendar event data
-   * @returns Created calendar event
-   */
-  async createPractitionerCalendarEvent(
-    practitionerId: string,
-    eventData: Omit<CreateCalendarEventData, "id" | "createdAt" | "updatedAt">
-  ): Promise<CalendarEvent> {
-    return createPractitionerCalendarEventUtil(
-      this.db,
-      practitionerId,
-      eventData,
-      this.generateId.bind(this)
-    );
-  }
-
-  /**
-   * Creates a calendar event for a patient
-   * @param patientId - ID of the patient
-   * @param eventData - Calendar event data
-   * @returns Created calendar event
-   */
-  async createPatientCalendarEvent(
-    patientId: string,
-    eventData: Omit<CreateCalendarEventData, "id" | "createdAt" | "updatedAt">
-  ): Promise<CalendarEvent> {
-    return createPatientCalendarEventUtil(
-      this.db,
-      patientId,
-      eventData,
-      this.generateId.bind(this)
-    );
-  }
-
-  /**
-   * Creates a calendar event for a clinic
-   * @param clinicId - ID of the clinic
-   * @param eventData - Calendar event data
-   * @returns Created calendar event
-   */
-  async createClinicCalendarEvent(
-    clinicId: string,
-    eventData: Omit<CreateCalendarEventData, "id" | "createdAt" | "updatedAt">
-  ): Promise<CalendarEvent> {
-    return createClinicCalendarEventUtil(
-      this.db,
-      clinicId,
-      eventData,
-      this.generateId.bind(this)
-    );
-  }
-
-  /**
-   * Creates an appointment across all relevant calendars (practitioner, patient, clinic)
-   * @param clinicId - ID of the clinic
-   * @param practitionerId - ID of the practitioner
-   * @param patientId - ID of the patient
-   * @param eventData - Calendar event data
-   * @param syncWithExternalCalendars - Whether to sync with external calendars
-   * @returns Created calendar event
-   */
-  async createAppointment(
-    clinicId: string,
-    practitionerId: string,
-    patientId: string,
-    eventData: Omit<
-      CreateCalendarEventData,
-      | "id"
-      | "createdAt"
-      | "updatedAt"
-      | "clinicBranchId"
-      | "practitionerProfileId"
-      | "patientProfileId"
-    >,
-    syncWithExternalCalendars: boolean = false
-  ): Promise<CalendarEvent> {
-    // Generate a single ID to be used across all calendars
-    const eventId = this.generateId();
-
-    // Prepare the event data with all required IDs
-    const appointmentData: Omit<
-      CreateCalendarEventData,
-      "id" | "createdAt" | "updatedAt"
-    > = {
-      ...eventData,
-      clinicBranchId: clinicId,
-      practitionerProfileId: practitionerId,
-      patientProfileId: patientId,
-      eventType: CalendarEventType.APPOINTMENT,
-      // Set sync status to INTERNAL as this is created in the app ecosystem
-      syncStatus: CalendarSyncStatus.INTERNAL,
-    };
-
-    // Create the event in all three calendars
-    const clinicPromise = this.createClinicCalendarEvent(
-      clinicId,
-      appointmentData
-    );
-
-    const practitionerPromise = this.createPractitionerCalendarEvent(
-      practitionerId,
-      appointmentData
-    );
-
-    const patientPromise = this.createPatientCalendarEvent(
-      patientId,
-      appointmentData
-    );
-
-    // Wait for all operations to complete
-    const [clinicEvent] = await Promise.all([
-      clinicPromise,
-      practitionerPromise,
-      patientPromise,
-    ]);
-
-    // Sync with external calendars if requested
-    if (syncWithExternalCalendars) {
-      try {
-        await this.syncAppointmentWithExternalCalendars(
-          clinicId,
-          practitionerId,
-          patientId,
-          clinicEvent.id
-        );
-      } catch (error) {
-        console.error(
-          "Error syncing appointment with external calendars:",
-          error
-        );
-        // Continue even if sync fails
-      }
-    }
-
-    // Return the event from the clinic calendar
-    return clinicEvent;
-  }
-
-  /**
-   * Gets a calendar event for a practitioner
-   * @param practitionerId - ID of the practitioner
-   * @param eventId - ID of the event
-   * @returns Calendar event or null if not found
-   */
-  async getPractitionerCalendarEvent(
-    practitionerId: string,
-    eventId: string
-  ): Promise<CalendarEvent | null> {
-    return getPractitionerCalendarEventUtil(this.db, practitionerId, eventId);
-  }
-
-  /**
-   * Gets a calendar event for a patient
-   * @param patientId - ID of the patient
-   * @param eventId - ID of the event
-   * @returns Calendar event or null if not found
-   */
-  async getPatientCalendarEvent(
-    patientId: string,
-    eventId: string
-  ): Promise<CalendarEvent | null> {
-    return getPatientCalendarEventUtil(this.db, patientId, eventId);
-  }
-
-  /**
-   * Gets a calendar event for a clinic
-   * @param clinicId - ID of the clinic
-   * @param eventId - ID of the event
-   * @returns Calendar event or null if not found
-   */
-  async getClinicCalendarEvent(
-    clinicId: string,
-    eventId: string
-  ): Promise<CalendarEvent | null> {
-    return getClinicCalendarEventUtil(this.db, clinicId, eventId);
-  }
-
-  /**
-   * Gets calendar events for a practitioner within a date range
-   * @param practitionerId - ID of the practitioner
-   * @param startDate - Start date of the range
-   * @param endDate - End date of the range
-   * @returns Array of calendar events
-   */
-  async getPractitionerCalendarEvents(
-    practitionerId: string,
-    startDate: Date,
-    endDate: Date
-  ): Promise<CalendarEvent[]> {
-    return getPractitionerCalendarEventsUtil(
-      this.db,
-      practitionerId,
-      startDate,
-      endDate
-    );
-  }
-
-  /**
-   * Gets calendar events for a patient within a date range
-   * @param patientId - ID of the patient
-   * @param startDate - Start date of the range
-   * @param endDate - End date of the range
-   * @returns Array of calendar events
-   */
-  async getPatientCalendarEvents(
-    patientId: string,
-    startDate: Date,
-    endDate: Date
-  ): Promise<CalendarEvent[]> {
-    return getPatientCalendarEventsUtil(this.db, patientId, startDate, endDate);
-  }
-
-  /**
-   * Gets calendar events for a clinic within a date range
-   * @param clinicId - ID of the clinic
-   * @param startDate - Start date of the range
-   * @param endDate - End date of the range
-   * @returns Array of calendar events
-   */
-  async getClinicCalendarEvents(
-    clinicId: string,
-    startDate: Date,
-    endDate: Date
-  ): Promise<CalendarEvent[]> {
-    return getClinicCalendarEventsUtil(this.db, clinicId, startDate, endDate);
-  }
-
-  /**
-   * Updates a calendar event for a practitioner
-   * @param practitionerId - ID of the practitioner
-   * @param eventId - ID of the event
-   * @param updateData - Data to update
-   * @returns Updated calendar event
-   */
-  async updatePractitionerCalendarEvent(
-    practitionerId: string,
-    eventId: string,
-    updateData: Omit<UpdateCalendarEventData, "updatedAt">
-  ): Promise<CalendarEvent> {
-    return updatePractitionerCalendarEventUtil(
-      this.db,
-      practitionerId,
-      eventId,
-      updateData
-    );
-  }
-
-  /**
-   * Updates a calendar event for a patient
-   * @param patientId - ID of the patient
-   * @param eventId - ID of the event
-   * @param updateData - Data to update
-   * @returns Updated calendar event
-   */
-  async updatePatientCalendarEvent(
-    patientId: string,
-    eventId: string,
-    updateData: Omit<UpdateCalendarEventData, "updatedAt">
-  ): Promise<CalendarEvent> {
-    return updatePatientCalendarEventUtil(
-      this.db,
-      patientId,
-      eventId,
-      updateData
-    );
-  }
-
-  /**
-   * Updates a calendar event for a clinic
-   * @param clinicId - ID of the clinic
-   * @param eventId - ID of the event
-   * @param updateData - Data to update
-   * @returns Updated calendar event
-   */
-  async updateClinicCalendarEvent(
-    clinicId: string,
-    eventId: string,
-    updateData: Omit<UpdateCalendarEventData, "updatedAt">
-  ): Promise<CalendarEvent> {
-    return updateClinicCalendarEventUtil(
-      this.db,
-      clinicId,
-      eventId,
-      updateData
-    );
-  }
-
-  /**
-   * Updates an appointment across all relevant calendars (practitioner, patient, clinic)
-   * @param clinicId - ID of the clinic
-   * @param practitionerId - ID of the practitioner
-   * @param patientId - ID of the patient
-   * @param eventId - ID of the event
-   * @param updateData - Data to update
-   * @param syncWithExternalCalendars - Whether to sync with external calendars
-   * @returns Updated calendar event
-   */
-  async updateAppointment(
-    clinicId: string,
-    practitionerId: string,
-    patientId: string,
-    eventId: string,
-    updateData: Omit<UpdateCalendarEventData, "updatedAt">,
-    syncWithExternalCalendars: boolean = false
-  ): Promise<CalendarEvent> {
-    // Update the event in all three calendars
-    const clinicPromise = this.updateClinicCalendarEvent(
-      clinicId,
-      eventId,
-      updateData
-    );
-
-    const practitionerPromise = this.updatePractitionerCalendarEvent(
-      practitionerId,
-      eventId,
-      updateData
-    );
-
-    const patientPromise = this.updatePatientCalendarEvent(
-      patientId,
-      eventId,
-      updateData
-    );
-
-    // Wait for all operations to complete
-    const [clinicEvent] = await Promise.all([
-      clinicPromise,
-      practitionerPromise,
-      patientPromise,
-    ]);
-
-    // Sync with external calendars if requested
-    if (syncWithExternalCalendars) {
-      try {
-        await this.syncAppointmentWithExternalCalendars(
-          clinicId,
-          practitionerId,
-          patientId,
-          eventId
-        );
-      } catch (error) {
-        console.error(
-          "Error syncing appointment with external calendars:",
-          error
-        );
-        // Continue even if sync fails
-      }
-    }
-
-    // Return the event from the clinic calendar
-    return clinicEvent;
-  }
-
-  /**
-   * Deletes a calendar event for a practitioner
-   * @param practitionerId - ID of the practitioner
-   * @param eventId - ID of the event
-   */
-  async deletePractitionerCalendarEvent(
-    practitionerId: string,
-    eventId: string
-  ): Promise<void> {
-    return deletePractitionerCalendarEventUtil(
-      this.db,
-      practitionerId,
-      eventId
-    );
-  }
-
-  /**
-   * Deletes a calendar event for a patient
-   * @param patientId - ID of the patient
-   * @param eventId - ID of the event
-   */
-  async deletePatientCalendarEvent(
-    patientId: string,
-    eventId: string
-  ): Promise<void> {
-    return deletePatientCalendarEventUtil(this.db, patientId, eventId);
-  }
-
-  /**
-   * Deletes a calendar event for a clinic
-   * @param clinicId - ID of the clinic
-   * @param eventId - ID of the event
-   */
-  async deleteClinicCalendarEvent(
-    clinicId: string,
-    eventId: string
-  ): Promise<void> {
-    return deleteClinicCalendarEventUtil(this.db, clinicId, eventId);
-  }
-
-  /**
-   * Deletes an appointment across all relevant calendars (practitioner, patient, clinic)
-   * @param clinicId - ID of the clinic
-   * @param practitionerId - ID of the practitioner
-   * @param patientId - ID of the patient
-   * @param eventId - ID of the event
-   */
-  async deleteAppointment(
-    clinicId: string,
-    practitionerId: string,
-    patientId: string,
-    eventId: string
-  ): Promise<void> {
-    // First get the appointment to check if it's synced with external calendars
-    const appointment = await this.getClinicCalendarEvent(clinicId, eventId);
-
-    if (appointment && appointment.syncStatus === CalendarSyncStatus.EXTERNAL) {
-      // Delete from external calendars
-      await this.deleteEventFromExternalCalendars(
-        appointment,
-        "clinic",
-        clinicId
-      );
-
-      // Also try to delete from practitioner and patient external calendars
-      const practitionerEvent = await this.getPractitionerCalendarEvent(
-        practitionerId,
-        eventId
-      );
-      if (practitionerEvent) {
-        await this.deleteEventFromExternalCalendars(
-          practitionerEvent,
-          "practitioner",
-          practitionerId
-        );
-      }
-
-      const patientEvent = await this.getPatientCalendarEvent(
-        patientId,
-        eventId
-      );
-      if (patientEvent) {
-        await this.deleteEventFromExternalCalendars(
-          patientEvent,
-          "patient",
-          patientId
-        );
-      }
-    }
-
-    // Delete the event from all three calendars
-    const clinicPromise = this.deleteClinicCalendarEvent(clinicId, eventId);
-
-    const practitionerPromise = this.deletePractitionerCalendarEvent(
-      practitionerId,
-      eventId
-    );
-
-    const patientPromise = this.deletePatientCalendarEvent(patientId, eventId);
-
-    // Wait for all operations to complete
-    await Promise.all([clinicPromise, practitionerPromise, patientPromise]);
-  }
-
-  /**
-   * Gets pending appointments for a clinic
-   * @param clinicId - ID of the clinic
-   * @returns Array of pending calendar events
-   */
-  async getPendingClinicAppointments(
-    clinicId: string
-  ): Promise<CalendarEvent[]> {
-    const events = await getClinicCalendarEventsUtil(
-      this.db,
-      clinicId,
-      new Date(0), // From the beginning of time
-      new Date(Date.now() + 365 * 24 * 60 * 60 * 1000) // To one year from now
-    );
-
-    return events.filter(
-      (event: CalendarEvent) =>
-        event.status === CalendarEventStatus.PENDING &&
-        event.eventType === CalendarEventType.APPOINTMENT
-    );
-  }
-
-  /**
-   * Gets confirmed appointments for a practitioner
-   * @param practitionerId - ID of the practitioner
-   * @returns Array of confirmed calendar events
-   */
-  async getConfirmedPractitionerAppointments(
-    practitionerId: string
-  ): Promise<CalendarEvent[]> {
-    const events = await getPractitionerCalendarEventsUtil(
-      this.db,
-      practitionerId,
-      new Date(0), // From the beginning of time
-      new Date(Date.now() + 365 * 24 * 60 * 60 * 1000) // To one year from now
-    );
-
-    return events.filter(
-      (event: CalendarEvent) =>
-        event.status === CalendarEventStatus.CONFIRMED &&
-        event.eventType === CalendarEventType.APPOINTMENT
-    );
-  }
-
-  /**
-   * Gets upcoming appointments for a patient
-   * @param patientId - ID of the patient
-   * @returns Array of upcoming calendar events
-   */
-  async getUpcomingPatientAppointments(
-    patientId: string
-  ): Promise<CalendarEvent[]> {
-    const now = new Date();
-    const events = await getPatientCalendarEventsUtil(
-      this.db,
-      patientId,
-      now,
-      new Date(Date.now() + 365 * 24 * 60 * 60 * 1000) // To one year from now
-    );
-
-    return events.filter(
-      (event: CalendarEvent) =>
-        event.eventType === CalendarEventType.APPOINTMENT
-    );
-  }
-
-  /**
-   * Confirms an appointment
-   * @param clinicId - ID of the clinic
-   * @param practitionerId - ID of the practitioner
-   * @param patientId - ID of the patient
-   * @param eventId - ID of the event
-   * @param syncWithExternalCalendars - Whether to sync with external calendars
-   * @returns Confirmed calendar event
-   */
-  async confirmAppointment(
-    clinicId: string,
-    practitionerId: string,
-    patientId: string,
-    eventId: string,
-    syncWithExternalCalendars: boolean = true
-  ): Promise<CalendarEvent> {
-    return this.updateAppointment(
-      clinicId,
-      practitionerId,
-      patientId,
-      eventId,
-      { status: CalendarEventStatus.CONFIRMED },
-      syncWithExternalCalendars
-    );
-  }
-
-  /**
-   * Rejects an appointment
-   * @param clinicId - ID of the clinic
-   * @param practitionerId - ID of the practitioner
-   * @param patientId - ID of the patient
-   * @param eventId - ID of the event
-   * @param syncWithExternalCalendars - Whether to sync with external calendars
-   * @returns Rejected calendar event
-   */
-  async rejectAppointment(
-    clinicId: string,
-    practitionerId: string,
-    patientId: string,
-    eventId: string,
-    syncWithExternalCalendars: boolean = true
-  ): Promise<CalendarEvent> {
-    return this.updateAppointment(
-      clinicId,
-      practitionerId,
-      patientId,
-      eventId,
-      { status: CalendarEventStatus.REJECTED },
-      syncWithExternalCalendars
-    );
-  }
-
-  /**
-   * Cancels an appointment
-   * @param clinicId - ID of the clinic
-   * @param practitionerId - ID of the practitioner
-   * @param patientId - ID of the patient
-   * @param eventId - ID of the event
-   * @param syncWithExternalCalendars - Whether to sync with external calendars
-   * @returns Canceled calendar event
-   */
-  async cancelAppointment(
-    clinicId: string,
-    practitionerId: string,
-    patientId: string,
-    eventId: string,
-    syncWithExternalCalendars: boolean = true
-  ): Promise<CalendarEvent> {
-    return this.updateAppointment(
-      clinicId,
-      practitionerId,
-      patientId,
-      eventId,
-      { status: CalendarEventStatus.CANCELED },
-      syncWithExternalCalendars
-    );
-  }
-
-  /**
-   * Reschedules an appointment
-   * @param clinicId - ID of the clinic
-   * @param practitionerId - ID of the practitioner
-   * @param patientId - ID of the patient
-   * @param eventId - ID of the event
-   * @param newEventTime - New event time
-   * @param syncWithExternalCalendars - Whether to sync with external calendars
-   * @returns Rescheduled calendar event
-   */
-  async rescheduleAppointment(
-    clinicId: string,
-    practitionerId: string,
-    patientId: string,
-    eventId: string,
-    newEventTime: CalendarEventTime,
-    syncWithExternalCalendars: boolean = true
-  ): Promise<CalendarEvent> {
-    // First get the current event to preserve any other fields
-    const currentEvent = await this.getClinicCalendarEvent(clinicId, eventId);
-
-    if (!currentEvent) {
-      throw new Error(`Appointment with ID ${eventId} not found`);
-    }
-
-    // Update the appointment with new time and status
-    return this.updateAppointment(
-      clinicId,
-      practitionerId,
-      patientId,
-      eventId,
-      {
-        status: CalendarEventStatus.RESCHEDULED,
-        eventTime: newEventTime,
-      },
-      syncWithExternalCalendars
-    );
-  }
-
-  /**
-   * Gets the SyncedCalendarsService for managing synced calendars
-   * @returns SyncedCalendarsService instance
-   */
-  getSyncedCalendarsService(): SyncedCalendarsService {
-    return this.syncedCalendarsService;
-  }
-
-  /**
-   * Syncs an appointment with external calendars
-   * @param clinicId - ID of the clinic
-   * @param practitionerId - ID of the practitioner
-   * @param patientId - ID of the patient
-   * @param eventId - ID of the event
-   * @returns Updated calendar event with sync information
-   */
-  async syncAppointmentWithExternalCalendars(
-    clinicId: string,
-    practitionerId: string,
-    patientId: string,
-    eventId: string
-  ): Promise<CalendarEvent> {
-    // Get the appointment
-    const appointment = await this.getClinicCalendarEvent(clinicId, eventId);
-
-    if (!appointment) {
-      throw new Error(`Appointment with ID ${eventId} not found`);
-    }
-
-    // Get synced calendars for all entities
-    const clinicCalendars =
-      await this.syncedCalendarsService.getClinicSyncedCalendars(clinicId);
-    const practitionerCalendars =
-      await this.syncedCalendarsService.getPractitionerSyncedCalendars(
-        practitionerId
-      );
-    const patientCalendars =
-      await this.syncedCalendarsService.getPatientSyncedCalendars(patientId);
-
-    // Combine all active calendars
-    const activeCalendars = [
-      ...clinicCalendars.filter((cal) => cal.isActive),
-      ...practitionerCalendars.filter((cal) => cal.isActive),
-      ...patientCalendars.filter((cal) => cal.isActive),
-    ];
-
-    // If no active calendars, return the appointment as is
-    if (activeCalendars.length === 0) {
-      return appointment;
-    }
-
-    // Array to store synced calendar event IDs
-    const syncedCalendarEvents: SyncedCalendarEvent[] = [];
-    const currentTime = Timestamp.now();
-
-    // Sync with each calendar
-    for (const calendar of activeCalendars) {
-      try {
-        // Sync based on provider
-        if (calendar.provider === SyncedCalendarProvider.GOOGLE) {
-          let syncResult;
-
-          // Determine which entity owns this calendar and sync accordingly
-          if (clinicCalendars.some((c) => c.id === calendar.id)) {
-            syncResult =
-              await this.syncedCalendarsService.syncClinicEventsToGoogleCalendar(
-                clinicId,
-                calendar.id,
-                [appointment]
-              );
-          } else if (practitionerCalendars.some((c) => c.id === calendar.id)) {
-            syncResult =
-              await this.syncedCalendarsService.syncPractitionerEventsToGoogleCalendar(
-                practitionerId,
-                calendar.id,
-                [appointment]
-              );
-          } else if (patientCalendars.some((c) => c.id === calendar.id)) {
-            syncResult =
-              await this.syncedCalendarsService.syncPatientEventsToGoogleCalendar(
-                patientId,
-                calendar.id,
-                [appointment]
-              );
-          }
-
-          // If sync was successful and we have event IDs, add them to our list
-          if (syncResult && syncResult.success && syncResult.syncedEvents > 0) {
-            // Get the external event ID - this might need to be adjusted based on the actual return structure
-            const externalEventId =
-              (syncResult as any).eventIds?.[0] || appointment.id;
-
-            syncedCalendarEvents.push({
-              eventId: externalEventId,
-              syncedCalendarProvider: SyncedCalendarProvider.GOOGLE,
-              syncedAt: currentTime,
-            });
-          }
-        }
-        // Add other providers as needed (Outlook, Apple, etc.)
-      } catch (error) {
-        console.error(`Error syncing with calendar ${calendar.id}:`, error);
-        // Continue with other calendars even if one fails
-      }
-    }
-
-    // Update the appointment with synced calendar information
-    if (syncedCalendarEvents.length > 0) {
-      return this.updateAppointment(
-        clinicId,
-        practitionerId,
-        patientId,
-        eventId,
-        {
-          syncedCalendarEventId: syncedCalendarEvents,
-        }
-      );
-    }
-
-    return appointment;
-  }
-
-  /**
-   * Imports events from external calendars
-   * @param entityType - Type of entity (practitioner, patient, clinic)
-   * @param entityId - ID of the entity
-   * @param startDate - Start date for fetching events
-   * @param endDate - End date for fetching events
-   * @returns Number of events imported
-   */
-  async importEventsFromExternalCalendars(
-    entityType: "practitioner" | "patient" | "clinic",
-    entityId: string,
-    startDate: Date,
-    endDate: Date
-  ): Promise<number> {
-    let syncedCalendars: any[] = [];
-
-    // Get synced calendars for the entity
-    switch (entityType) {
-      case "practitioner":
-        syncedCalendars =
-          await this.syncedCalendarsService.getPractitionerSyncedCalendars(
-            entityId
-          );
-        break;
-      case "patient":
-        syncedCalendars =
-          await this.syncedCalendarsService.getPatientSyncedCalendars(entityId);
-        break;
-      case "clinic":
-        syncedCalendars =
-          await this.syncedCalendarsService.getClinicSyncedCalendars(entityId);
-        break;
-    }
-
-    // Filter active calendars
-    const activeCalendars = syncedCalendars.filter((cal) => cal.isActive);
-
-    if (activeCalendars.length === 0) {
-      return 0;
-    }
-
-    let importedEventsCount = 0;
-    const currentTime = Timestamp.now();
-
-    // Import from each calendar
-    for (const calendar of activeCalendars) {
-      try {
-        let externalEvents: any[] = [];
-
-        // Fetch events based on provider and entity type
-        if (calendar.provider === SyncedCalendarProvider.GOOGLE) {
-          switch (entityType) {
-            case "practitioner":
-              externalEvents =
-                await this.syncedCalendarsService.fetchEventsFromPractitionerGoogleCalendar(
-                  entityId,
-                  calendar.id,
-                  startDate,
-                  endDate
-                );
-              break;
-            case "patient":
-              externalEvents =
-                await this.syncedCalendarsService.fetchEventsFromPatientGoogleCalendar(
-                  entityId,
-                  calendar.id,
-                  startDate,
-                  endDate
-                );
-              break;
-            case "clinic":
-              externalEvents =
-                await this.syncedCalendarsService.fetchEventsFromClinicGoogleCalendar(
-                  entityId,
-                  calendar.id,
-                  startDate,
-                  endDate
-                );
-              break;
-          }
-        }
-        // Add other providers as needed
-
-        // Process and import each event
-        for (const externalEvent of externalEvents) {
-          try {
-            // Create event data from external event
-            const eventData: Omit<
-              CreateCalendarEventData,
-              "id" | "createdAt" | "updatedAt"
-            > = {
-              eventName: externalEvent.summary || "Imported Event",
-              eventTime: {
-                start: Timestamp.fromDate(
-                  new Date(
-                    externalEvent.start.dateTime || externalEvent.start.date
-                  )
-                ),
-                end: Timestamp.fromDate(
-                  new Date(externalEvent.end.dateTime || externalEvent.end.date)
-                ),
-              },
-              description: externalEvent.description || "",
-              status: CalendarEventStatus.CONFIRMED,
-              // Set sync status to EXTERNAL as this is imported from an external calendar
-              syncStatus: CalendarSyncStatus.EXTERNAL,
-              eventType: CalendarEventType.BLOCKING, // Use BLOCKING type for external events
-              syncedCalendarEventId: [
-                {
-                  eventId: externalEvent.id,
-                  syncedCalendarProvider: calendar.provider,
-                  syncedAt: currentTime,
-                },
-              ],
-            };
-
-            // Create the event in our system
-            switch (entityType) {
-              case "practitioner":
-                await this.createPractitionerCalendarEvent(entityId, eventData);
-                break;
-              case "patient":
-                await this.createPatientCalendarEvent(entityId, eventData);
-                break;
-              case "clinic":
-                await this.createClinicCalendarEvent(entityId, eventData);
-                break;
-            }
-
-            importedEventsCount++;
-          } catch (eventError) {
-            console.error("Error importing event:", eventError);
-            // Continue with other events even if one fails
-          }
-        }
-      } catch (calendarError) {
-        console.error(
-          `Error fetching events from calendar ${calendar.id}:`,
-          calendarError
-        );
-        // Continue with other calendars even if one fails
-      }
-    }
-
-    return importedEventsCount;
-  }
-
-  /**
-   * Deletes an event from external calendars
-   * @param event - Calendar event to delete
-   * @param entityType - Type of entity (practitioner, patient, clinic)
-   * @param entityId - ID of the entity
-   * @returns Success status
-   */
-  async deleteEventFromExternalCalendars(
-    event: CalendarEvent,
-    entityType: "practitioner" | "patient" | "clinic",
-    entityId: string
-  ): Promise<boolean> {
-    // If the event doesn't have synced calendar event IDs, return success
-    if (
-      !event.syncedCalendarEventId ||
-      event.syncedCalendarEventId.length === 0
-    ) {
-      return true;
-    }
-
-    // Get synced calendars for the entity
-    let syncedCalendars: any[] = [];
-    switch (entityType) {
-      case "practitioner":
-        syncedCalendars =
-          await this.syncedCalendarsService.getPractitionerSyncedCalendars(
-            entityId
-          );
-        break;
-      case "patient":
-        syncedCalendars =
-          await this.syncedCalendarsService.getPatientSyncedCalendars(entityId);
-        break;
-      case "clinic":
-        syncedCalendars =
-          await this.syncedCalendarsService.getClinicSyncedCalendars(entityId);
-        break;
-    }
-
-    // Filter active calendars
-    const activeCalendars = syncedCalendars.filter((cal) => cal.isActive);
-
-    if (activeCalendars.length === 0) {
-      return true;
-    }
-
-    let allSuccessful = true;
-
-    // Delete from each external calendar
-    for (const syncedEvent of event.syncedCalendarEventId) {
-      try {
-        // Find the calendar for this provider
-        const calendar = activeCalendars.find(
-          (cal) => cal.provider === syncedEvent.syncedCalendarProvider
-        );
-
-        if (!calendar) {
-          continue;
-        }
-
-        // Delete based on provider and entity type
-        if (
-          syncedEvent.syncedCalendarProvider === SyncedCalendarProvider.GOOGLE
-        ) {
-          let success = false;
-
-          switch (entityType) {
-            case "practitioner":
-              success =
-                await this.syncedCalendarsService.deletePractitionerGoogleCalendarEvent(
-                  entityId,
-                  calendar.id,
-                  syncedEvent.eventId
-                );
-              break;
-            case "patient":
-              success =
-                await this.syncedCalendarsService.deletePatientGoogleCalendarEvent(
-                  entityId,
-                  calendar.id,
-                  syncedEvent.eventId
-                );
-              break;
-            case "clinic":
-              success =
-                await this.syncedCalendarsService.deleteClinicGoogleCalendarEvent(
-                  entityId,
-                  calendar.id,
-                  syncedEvent.eventId
-                );
-              break;
-          }
-
-          if (!success) {
-            allSuccessful = false;
-          }
-        }
-        // Add other providers as needed
-      } catch (error) {
-        console.error(`Error deleting event from external calendar:`, error);
-        allSuccessful = false;
-      }
-    }
-
-    return allSuccessful;
-  }
-}
+import { Auth } from "firebase/auth";
+import { Firestore, Timestamp } from "firebase/firestore";
+import { FirebaseApp } from "firebase/app";
+import { BaseService } from "../base.service";
+import {
+  CalendarEvent,
+  CalendarEventStatus,
+  CalendarEventTime,
+  CalendarEventType,
+  CalendarSyncStatus,
+  CreateCalendarEventData,
+  UpdateCalendarEventData,
+  CALENDAR_COLLECTION,
+  SyncedCalendarEvent,
+} from "../../types/calendar";
+import { PRACTITIONERS_COLLECTION } from "../../types/practitioner";
+import { PATIENTS_COLLECTION } from "../../types/patient";
+import { CLINICS_COLLECTION } from "../../types/clinic";
+import { SyncedCalendarProvider } from "../../types/calendar/synced-calendar.types";
+
+// Import utility functions from the index file
+import {
+  createPractitionerCalendarEventUtil,
+  createPatientCalendarEventUtil,
+  createClinicCalendarEventUtil,
+  getPractitionerCalendarEventUtil,
+  getPatientCalendarEventUtil,
+  getClinicCalendarEventUtil,
+  getPractitionerCalendarEventsUtil,
+  getPatientCalendarEventsUtil,
+  getClinicCalendarEventsUtil,
+  updatePractitionerCalendarEventUtil,
+  updatePatientCalendarEventUtil,
+  updateClinicCalendarEventUtil,
+  deletePractitionerCalendarEventUtil,
+  deletePatientCalendarEventUtil,
+  deleteClinicCalendarEventUtil,
+} from "./utils";
+
+// Import the SyncedCalendarsService for calendar synchronization
+import { SyncedCalendarsService } from "./synced-calendars.service";
+
+/**
+ * Service for managing calendar events
+ */
+export class CalendarService extends BaseService {
+  private syncedCalendarsService: SyncedCalendarsService;
+
+  /**
+   * Creates a new CalendarService instance
+   * @param db - Firestore instance
+   * @param auth - Firebase Auth instance
+   * @param app - Firebase App instance
+   */
+  constructor(db: Firestore, auth: Auth, app: FirebaseApp) {
+    super(db, auth, app);
+    this.syncedCalendarsService = new SyncedCalendarsService(db, auth, app);
+  }
+
+  /**
+   * Creates a calendar event for a practitioner
+   * @param practitionerId - ID of the practitioner
+   * @param eventData - Calendar event data
+   * @returns Created calendar event
+   */
+  async createPractitionerCalendarEvent(
+    practitionerId: string,
+    eventData: Omit<CreateCalendarEventData, "id" | "createdAt" | "updatedAt">
+  ): Promise<CalendarEvent> {
+    return createPractitionerCalendarEventUtil(
+      this.db,
+      practitionerId,
+      eventData,
+      this.generateId.bind(this)
+    );
+  }
+
+  /**
+   * Creates a calendar event for a patient
+   * @param patientId - ID of the patient
+   * @param eventData - Calendar event data
+   * @returns Created calendar event
+   */
+  async createPatientCalendarEvent(
+    patientId: string,
+    eventData: Omit<CreateCalendarEventData, "id" | "createdAt" | "updatedAt">
+  ): Promise<CalendarEvent> {
+    return createPatientCalendarEventUtil(
+      this.db,
+      patientId,
+      eventData,
+      this.generateId.bind(this)
+    );
+  }
+
+  /**
+   * Creates a calendar event for a clinic
+   * @param clinicId - ID of the clinic
+   * @param eventData - Calendar event data
+   * @returns Created calendar event
+   */
+  async createClinicCalendarEvent(
+    clinicId: string,
+    eventData: Omit<CreateCalendarEventData, "id" | "createdAt" | "updatedAt">
+  ): Promise<CalendarEvent> {
+    return createClinicCalendarEventUtil(
+      this.db,
+      clinicId,
+      eventData,
+      this.generateId.bind(this)
+    );
+  }
+
+  /**
+   * Creates an appointment across all relevant calendars (practitioner, patient, clinic)
+   * @param clinicId - ID of the clinic
+   * @param practitionerId - ID of the practitioner
+   * @param patientId - ID of the patient
+   * @param eventData - Calendar event data
+   * @param syncWithExternalCalendars - Whether to sync with external calendars
+   * @returns Created calendar event
+   */
+  async createAppointment(
+    clinicId: string,
+    practitionerId: string,
+    patientId: string,
+    eventData: Omit<
+      CreateCalendarEventData,
+      | "id"
+      | "createdAt"
+      | "updatedAt"
+      | "clinicBranchId"
+      | "practitionerProfileId"
+      | "patientProfileId"
+    >,
+    syncWithExternalCalendars: boolean = false
+  ): Promise<CalendarEvent> {
+    // Generate a single ID to be used across all calendars
+    const eventId = this.generateId();
+
+    // Prepare the event data with all required IDs
+    const appointmentData: Omit<
+      CreateCalendarEventData,
+      "id" | "createdAt" | "updatedAt"
+    > = {
+      ...eventData,
+      clinicBranchId: clinicId,
+      practitionerProfileId: practitionerId,
+      patientProfileId: patientId,
+      eventType: CalendarEventType.APPOINTMENT,
+      // Set sync status to INTERNAL as this is created in the app ecosystem
+      syncStatus: CalendarSyncStatus.INTERNAL,
+    };
+
+    // Create the event in all three calendars
+    const clinicPromise = this.createClinicCalendarEvent(
+      clinicId,
+      appointmentData
+    );
+
+    const practitionerPromise = this.createPractitionerCalendarEvent(
+      practitionerId,
+      appointmentData
+    );
+
+    const patientPromise = this.createPatientCalendarEvent(
+      patientId,
+      appointmentData
+    );
+
+    // Wait for all operations to complete
+    const [clinicEvent] = await Promise.all([
+      clinicPromise,
+      practitionerPromise,
+      patientPromise,
+    ]);
+
+    // Sync with external calendars if requested
+    if (syncWithExternalCalendars) {
+      try {
+        await this.syncAppointmentWithExternalCalendars(
+          clinicId,
+          practitionerId,
+          patientId,
+          clinicEvent.id
+        );
+      } catch (error) {
+        console.error(
+          "Error syncing appointment with external calendars:",
+          error
+        );
+        // Continue even if sync fails
+      }
+    }
+
+    // Return the event from the clinic calendar
+    return clinicEvent;
+  }
+
+  /**
+   * Gets a calendar event for a practitioner
+   * @param practitionerId - ID of the practitioner
+   * @param eventId - ID of the event
+   * @returns Calendar event or null if not found
+   */
+  async getPractitionerCalendarEvent(
+    practitionerId: string,
+    eventId: string
+  ): Promise<CalendarEvent | null> {
+    return getPractitionerCalendarEventUtil(this.db, practitionerId, eventId);
+  }
+
+  /**
+   * Gets a calendar event for a patient
+   * @param patientId - ID of the patient
+   * @param eventId - ID of the event
+   * @returns Calendar event or null if not found
+   */
+  async getPatientCalendarEvent(
+    patientId: string,
+    eventId: string
+  ): Promise<CalendarEvent | null> {
+    return getPatientCalendarEventUtil(this.db, patientId, eventId);
+  }
+
+  /**
+   * Gets a calendar event for a clinic
+   * @param clinicId - ID of the clinic
+   * @param eventId - ID of the event
+   * @returns Calendar event or null if not found
+   */
+  async getClinicCalendarEvent(
+    clinicId: string,
+    eventId: string
+  ): Promise<CalendarEvent | null> {
+    return getClinicCalendarEventUtil(this.db, clinicId, eventId);
+  }
+
+  /**
+   * Gets calendar events for a practitioner within a date range
+   * @param practitionerId - ID of the practitioner
+   * @param startDate - Start date of the range
+   * @param endDate - End date of the range
+   * @returns Array of calendar events
+   */
+  async getPractitionerCalendarEvents(
+    practitionerId: string,
+    startDate: Date,
+    endDate: Date
+  ): Promise<CalendarEvent[]> {
+    return getPractitionerCalendarEventsUtil(
+      this.db,
+      practitionerId,
+      startDate,
+      endDate
+    );
+  }
+
+  /**
+   * Gets calendar events for a patient within a date range
+   * @param patientId - ID of the patient
+   * @param startDate - Start date of the range
+   * @param endDate - End date of the range
+   * @returns Array of calendar events
+   */
+  async getPatientCalendarEvents(
+    patientId: string,
+    startDate: Date,
+    endDate: Date
+  ): Promise<CalendarEvent[]> {
+    return getPatientCalendarEventsUtil(this.db, patientId, startDate, endDate);
+  }
+
+  /**
+   * Gets calendar events for a clinic within a date range
+   * @param clinicId - ID of the clinic
+   * @param startDate - Start date of the range
+   * @param endDate - End date of the range
+   * @returns Array of calendar events
+   */
+  async getClinicCalendarEvents(
+    clinicId: string,
+    startDate: Date,
+    endDate: Date
+  ): Promise<CalendarEvent[]> {
+    return getClinicCalendarEventsUtil(this.db, clinicId, startDate, endDate);
+  }
+
+  /**
+   * Updates a calendar event for a practitioner
+   * @param practitionerId - ID of the practitioner
+   * @param eventId - ID of the event
+   * @param updateData - Data to update
+   * @returns Updated calendar event
+   */
+  async updatePractitionerCalendarEvent(
+    practitionerId: string,
+    eventId: string,
+    updateData: Omit<UpdateCalendarEventData, "updatedAt">
+  ): Promise<CalendarEvent> {
+    return updatePractitionerCalendarEventUtil(
+      this.db,
+      practitionerId,
+      eventId,
+      updateData
+    );
+  }
+
+  /**
+   * Updates a calendar event for a patient
+   * @param patientId - ID of the patient
+   * @param eventId - ID of the event
+   * @param updateData - Data to update
+   * @returns Updated calendar event
+   */
+  async updatePatientCalendarEvent(
+    patientId: string,
+    eventId: string,
+    updateData: Omit<UpdateCalendarEventData, "updatedAt">
+  ): Promise<CalendarEvent> {
+    return updatePatientCalendarEventUtil(
+      this.db,
+      patientId,
+      eventId,
+      updateData
+    );
+  }
+
+  /**
+   * Updates a calendar event for a clinic
+   * @param clinicId - ID of the clinic
+   * @param eventId - ID of the event
+   * @param updateData - Data to update
+   * @returns Updated calendar event
+   */
+  async updateClinicCalendarEvent(
+    clinicId: string,
+    eventId: string,
+    updateData: Omit<UpdateCalendarEventData, "updatedAt">
+  ): Promise<CalendarEvent> {
+    return updateClinicCalendarEventUtil(
+      this.db,
+      clinicId,
+      eventId,
+      updateData
+    );
+  }
+
+  /**
+   * Updates an appointment across all relevant calendars (practitioner, patient, clinic)
+   * @param clinicId - ID of the clinic
+   * @param practitionerId - ID of the practitioner
+   * @param patientId - ID of the patient
+   * @param eventId - ID of the event
+   * @param updateData - Data to update
+   * @param syncWithExternalCalendars - Whether to sync with external calendars
+   * @returns Updated calendar event
+   */
+  async updateAppointment(
+    clinicId: string,
+    practitionerId: string,
+    patientId: string,
+    eventId: string,
+    updateData: Omit<UpdateCalendarEventData, "updatedAt">,
+    syncWithExternalCalendars: boolean = false
+  ): Promise<CalendarEvent> {
+    // Update the event in all three calendars
+    const clinicPromise = this.updateClinicCalendarEvent(
+      clinicId,
+      eventId,
+      updateData
+    );
+
+    const practitionerPromise = this.updatePractitionerCalendarEvent(
+      practitionerId,
+      eventId,
+      updateData
+    );
+
+    const patientPromise = this.updatePatientCalendarEvent(
+      patientId,
+      eventId,
+      updateData
+    );
+
+    // Wait for all operations to complete
+    const [clinicEvent] = await Promise.all([
+      clinicPromise,
+      practitionerPromise,
+      patientPromise,
+    ]);
+
+    // Sync with external calendars if requested
+    if (syncWithExternalCalendars) {
+      try {
+        await this.syncAppointmentWithExternalCalendars(
+          clinicId,
+          practitionerId,
+          patientId,
+          eventId
+        );
+      } catch (error) {
+        console.error(
+          "Error syncing appointment with external calendars:",
+          error
+        );
+        // Continue even if sync fails
+      }
+    }
+
+    // Return the event from the clinic calendar
+    return clinicEvent;
+  }
+
+  /**
+   * Deletes a calendar event for a practitioner
+   * @param practitionerId - ID of the practitioner
+   * @param eventId - ID of the event
+   */
+  async deletePractitionerCalendarEvent(
+    practitionerId: string,
+    eventId: string
+  ): Promise<void> {
+    return deletePractitionerCalendarEventUtil(
+      this.db,
+      practitionerId,
+      eventId
+    );
+  }
+
+  /**
+   * Deletes a calendar event for a patient
+   * @param patientId - ID of the patient
+   * @param eventId - ID of the event
+   */
+  async deletePatientCalendarEvent(
+    patientId: string,
+    eventId: string
+  ): Promise<void> {
+    return deletePatientCalendarEventUtil(this.db, patientId, eventId);
+  }
+
+  /**
+   * Deletes a calendar event for a clinic
+   * @param clinicId - ID of the clinic
+   * @param eventId - ID of the event
+   */
+  async deleteClinicCalendarEvent(
+    clinicId: string,
+    eventId: string
+  ): Promise<void> {
+    return deleteClinicCalendarEventUtil(this.db, clinicId, eventId);
+  }
+
+  /**
+   * Deletes an appointment across all relevant calendars (practitioner, patient, clinic)
+   * @param clinicId - ID of the clinic
+   * @param practitionerId - ID of the practitioner
+   * @param patientId - ID of the patient
+   * @param eventId - ID of the event
+   */
+  async deleteAppointment(
+    clinicId: string,
+    practitionerId: string,
+    patientId: string,
+    eventId: string
+  ): Promise<void> {
+    // First get the appointment to check if it's synced with external calendars
+    const appointment = await this.getClinicCalendarEvent(clinicId, eventId);
+
+    if (appointment && appointment.syncStatus === CalendarSyncStatus.EXTERNAL) {
+      // Delete from external calendars
+      await this.deleteEventFromExternalCalendars(
+        appointment,
+        "clinic",
+        clinicId
+      );
+
+      // Also try to delete from practitioner and patient external calendars
+      const practitionerEvent = await this.getPractitionerCalendarEvent(
+        practitionerId,
+        eventId
+      );
+      if (practitionerEvent) {
+        await this.deleteEventFromExternalCalendars(
+          practitionerEvent,
+          "practitioner",
+          practitionerId
+        );
+      }
+
+      const patientEvent = await this.getPatientCalendarEvent(
+        patientId,
+        eventId
+      );
+      if (patientEvent) {
+        await this.deleteEventFromExternalCalendars(
+          patientEvent,
+          "patient",
+          patientId
+        );
+      }
+    }
+
+    // Delete the event from all three calendars
+    const clinicPromise = this.deleteClinicCalendarEvent(clinicId, eventId);
+
+    const practitionerPromise = this.deletePractitionerCalendarEvent(
+      practitionerId,
+      eventId
+    );
+
+    const patientPromise = this.deletePatientCalendarEvent(patientId, eventId);
+
+    // Wait for all operations to complete
+    await Promise.all([clinicPromise, practitionerPromise, patientPromise]);
+  }
+
+  /**
+   * Gets pending appointments for a clinic
+   * @param clinicId - ID of the clinic
+   * @returns Array of pending calendar events
+   */
+  async getPendingClinicAppointments(
+    clinicId: string
+  ): Promise<CalendarEvent[]> {
+    const events = await getClinicCalendarEventsUtil(
+      this.db,
+      clinicId,
+      new Date(0), // From the beginning of time
+      new Date(Date.now() + 365 * 24 * 60 * 60 * 1000) // To one year from now
+    );
+
+    return events.filter(
+      (event: CalendarEvent) =>
+        event.status === CalendarEventStatus.PENDING &&
+        event.eventType === CalendarEventType.APPOINTMENT
+    );
+  }
+
+  /**
+   * Gets confirmed appointments for a practitioner
+   * @param practitionerId - ID of the practitioner
+   * @returns Array of confirmed calendar events
+   */
+  async getConfirmedPractitionerAppointments(
+    practitionerId: string
+  ): Promise<CalendarEvent[]> {
+    const events = await getPractitionerCalendarEventsUtil(
+      this.db,
+      practitionerId,
+      new Date(0), // From the beginning of time
+      new Date(Date.now() + 365 * 24 * 60 * 60 * 1000) // To one year from now
+    );
+
+    return events.filter(
+      (event: CalendarEvent) =>
+        event.status === CalendarEventStatus.CONFIRMED &&
+        event.eventType === CalendarEventType.APPOINTMENT
+    );
+  }
+
+  /**
+   * Gets upcoming appointments for a patient
+   * @param patientId - ID of the patient
+   * @returns Array of upcoming calendar events
+   */
+  async getUpcomingPatientAppointments(
+    patientId: string
+  ): Promise<CalendarEvent[]> {
+    const now = new Date();
+    const events = await getPatientCalendarEventsUtil(
+      this.db,
+      patientId,
+      now,
+      new Date(Date.now() + 365 * 24 * 60 * 60 * 1000) // To one year from now
+    );
+
+    return events.filter(
+      (event: CalendarEvent) =>
+        event.eventType === CalendarEventType.APPOINTMENT
+    );
+  }
+
+  /**
+   * Confirms an appointment
+   * @param clinicId - ID of the clinic
+   * @param practitionerId - ID of the practitioner
+   * @param patientId - ID of the patient
+   * @param eventId - ID of the event
+   * @param syncWithExternalCalendars - Whether to sync with external calendars
+   * @returns Confirmed calendar event
+   */
+  async confirmAppointment(
+    clinicId: string,
+    practitionerId: string,
+    patientId: string,
+    eventId: string,
+    syncWithExternalCalendars: boolean = true
+  ): Promise<CalendarEvent> {
+    return this.updateAppointment(
+      clinicId,
+      practitionerId,
+      patientId,
+      eventId,
+      { status: CalendarEventStatus.CONFIRMED },
+      syncWithExternalCalendars
+    );
+  }
+
+  /**
+   * Rejects an appointment
+   * @param clinicId - ID of the clinic
+   * @param practitionerId - ID of the practitioner
+   * @param patientId - ID of the patient
+   * @param eventId - ID of the event
+   * @param syncWithExternalCalendars - Whether to sync with external calendars
+   * @returns Rejected calendar event
+   */
+  async rejectAppointment(
+    clinicId: string,
+    practitionerId: string,
+    patientId: string,
+    eventId: string,
+    syncWithExternalCalendars: boolean = true
+  ): Promise<CalendarEvent> {
+    return this.updateAppointment(
+      clinicId,
+      practitionerId,
+      patientId,
+      eventId,
+      { status: CalendarEventStatus.REJECTED },
+      syncWithExternalCalendars
+    );
+  }
+
+  /**
+   * Cancels an appointment
+   * @param clinicId - ID of the clinic
+   * @param practitionerId - ID of the practitioner
+   * @param patientId - ID of the patient
+   * @param eventId - ID of the event
+   * @param syncWithExternalCalendars - Whether to sync with external calendars
+   * @returns Canceled calendar event
+   */
+  async cancelAppointment(
+    clinicId: string,
+    practitionerId: string,
+    patientId: string,
+    eventId: string,
+    syncWithExternalCalendars: boolean = true
+  ): Promise<CalendarEvent> {
+    return this.updateAppointment(
+      clinicId,
+      practitionerId,
+      patientId,
+      eventId,
+      { status: CalendarEventStatus.CANCELED },
+      syncWithExternalCalendars
+    );
+  }
+
+  /**
+   * Reschedules an appointment
+   * @param clinicId - ID of the clinic
+   * @param practitionerId - ID of the practitioner
+   * @param patientId - ID of the patient
+   * @param eventId - ID of the event
+   * @param newEventTime - New event time
+   * @param syncWithExternalCalendars - Whether to sync with external calendars
+   * @returns Rescheduled calendar event
+   */
+  async rescheduleAppointment(
+    clinicId: string,
+    practitionerId: string,
+    patientId: string,
+    eventId: string,
+    newEventTime: CalendarEventTime,
+    syncWithExternalCalendars: boolean = true
+  ): Promise<CalendarEvent> {
+    // First get the current event to preserve any other fields
+    const currentEvent = await this.getClinicCalendarEvent(clinicId, eventId);
+
+    if (!currentEvent) {
+      throw new Error(`Appointment with ID ${eventId} not found`);
+    }
+
+    // Update the appointment with new time and status
+    return this.updateAppointment(
+      clinicId,
+      practitionerId,
+      patientId,
+      eventId,
+      {
+        status: CalendarEventStatus.RESCHEDULED,
+        eventTime: newEventTime,
+      },
+      syncWithExternalCalendars
+    );
+  }
+
+  /**
+   * Gets the SyncedCalendarsService for managing synced calendars
+   * @returns SyncedCalendarsService instance
+   */
+  getSyncedCalendarsService(): SyncedCalendarsService {
+    return this.syncedCalendarsService;
+  }
+
+  /**
+   * Syncs an appointment with external calendars
+   * @param clinicId - ID of the clinic
+   * @param practitionerId - ID of the practitioner
+   * @param patientId - ID of the patient
+   * @param eventId - ID of the event
+   * @returns Updated calendar event with sync information
+   */
+  async syncAppointmentWithExternalCalendars(
+    clinicId: string,
+    practitionerId: string,
+    patientId: string,
+    eventId: string
+  ): Promise<CalendarEvent> {
+    // Get the appointment
+    const appointment = await this.getClinicCalendarEvent(clinicId, eventId);
+
+    if (!appointment) {
+      throw new Error(`Appointment with ID ${eventId} not found`);
+    }
+
+    // Get synced calendars for all entities
+    const clinicCalendars =
+      await this.syncedCalendarsService.getClinicSyncedCalendars(clinicId);
+    const practitionerCalendars =
+      await this.syncedCalendarsService.getPractitionerSyncedCalendars(
+        practitionerId
+      );
+    const patientCalendars =
+      await this.syncedCalendarsService.getPatientSyncedCalendars(patientId);
+
+    // Combine all active calendars
+    const activeCalendars = [
+      ...clinicCalendars.filter((cal) => cal.isActive),
+      ...practitionerCalendars.filter((cal) => cal.isActive),
+      ...patientCalendars.filter((cal) => cal.isActive),
+    ];
+
+    // If no active calendars, return the appointment as is
+    if (activeCalendars.length === 0) {
+      return appointment;
+    }
+
+    // Array to store synced calendar event IDs
+    const syncedCalendarEvents: SyncedCalendarEvent[] = [];
+    const currentTime = Timestamp.now();
+
+    // Sync with each calendar
+    for (const calendar of activeCalendars) {
+      try {
+        // Sync based on provider
+        if (calendar.provider === SyncedCalendarProvider.GOOGLE) {
+          let syncResult;
+
+          // Determine which entity owns this calendar and sync accordingly
+          if (clinicCalendars.some((c) => c.id === calendar.id)) {
+            syncResult =
+              await this.syncedCalendarsService.syncClinicEventsToGoogleCalendar(
+                clinicId,
+                calendar.id,
+                [appointment]
+              );
+          } else if (practitionerCalendars.some((c) => c.id === calendar.id)) {
+            syncResult =
+              await this.syncedCalendarsService.syncPractitionerEventsToGoogleCalendar(
+                practitionerId,
+                calendar.id,
+                [appointment]
+              );
+          } else if (patientCalendars.some((c) => c.id === calendar.id)) {
+            syncResult =
+              await this.syncedCalendarsService.syncPatientEventsToGoogleCalendar(
+                patientId,
+                calendar.id,
+                [appointment]
+              );
+          }
+
+          // If sync was successful and we have event IDs, add them to our list
+          if (syncResult && syncResult.success && syncResult.syncedEvents > 0) {
+            // Get the external event ID - this might need to be adjusted based on the actual return structure
+            const externalEventId =
+              (syncResult as any).eventIds?.[0] || appointment.id;
+
+            syncedCalendarEvents.push({
+              eventId: externalEventId,
+              syncedCalendarProvider: SyncedCalendarProvider.GOOGLE,
+              syncedAt: currentTime,
+            });
+          }
+        }
+        // Add other providers as needed (Outlook, Apple, etc.)
+      } catch (error) {
+        console.error(`Error syncing with calendar ${calendar.id}:`, error);
+        // Continue with other calendars even if one fails
+      }
+    }
+
+    // Update the appointment with synced calendar information
+    if (syncedCalendarEvents.length > 0) {
+      return this.updateAppointment(
+        clinicId,
+        practitionerId,
+        patientId,
+        eventId,
+        {
+          syncedCalendarEventId: syncedCalendarEvents,
+        }
+      );
+    }
+
+    return appointment;
+  }
+
+  /**
+   * Imports events from external calendars
+   * @param entityType - Type of entity (practitioner, patient, clinic)
+   * @param entityId - ID of the entity
+   * @param startDate - Start date for fetching events
+   * @param endDate - End date for fetching events
+   * @returns Number of events imported
+   */
+  async importEventsFromExternalCalendars(
+    entityType: "practitioner" | "patient" | "clinic",
+    entityId: string,
+    startDate: Date,
+    endDate: Date
+  ): Promise<number> {
+    let syncedCalendars: any[] = [];
+
+    // Get synced calendars for the entity
+    switch (entityType) {
+      case "practitioner":
+        syncedCalendars =
+          await this.syncedCalendarsService.getPractitionerSyncedCalendars(
+            entityId
+          );
+        break;
+      case "patient":
+        syncedCalendars =
+          await this.syncedCalendarsService.getPatientSyncedCalendars(entityId);
+        break;
+      case "clinic":
+        syncedCalendars =
+          await this.syncedCalendarsService.getClinicSyncedCalendars(entityId);
+        break;
+    }
+
+    // Filter active calendars
+    const activeCalendars = syncedCalendars.filter((cal) => cal.isActive);
+
+    if (activeCalendars.length === 0) {
+      return 0;
+    }
+
+    let importedEventsCount = 0;
+    const currentTime = Timestamp.now();
+
+    // Import from each calendar
+    for (const calendar of activeCalendars) {
+      try {
+        let externalEvents: any[] = [];
+
+        // Fetch events based on provider and entity type
+        if (calendar.provider === SyncedCalendarProvider.GOOGLE) {
+          switch (entityType) {
+            case "practitioner":
+              externalEvents =
+                await this.syncedCalendarsService.fetchEventsFromPractitionerGoogleCalendar(
+                  entityId,
+                  calendar.id,
+                  startDate,
+                  endDate
+                );
+              break;
+            case "patient":
+              externalEvents =
+                await this.syncedCalendarsService.fetchEventsFromPatientGoogleCalendar(
+                  entityId,
+                  calendar.id,
+                  startDate,
+                  endDate
+                );
+              break;
+            case "clinic":
+              externalEvents =
+                await this.syncedCalendarsService.fetchEventsFromClinicGoogleCalendar(
+                  entityId,
+                  calendar.id,
+                  startDate,
+                  endDate
+                );
+              break;
+          }
+        }
+        // Add other providers as needed
+
+        // Process and import each event
+        for (const externalEvent of externalEvents) {
+          try {
+            // Create event data from external event
+            const eventData: Omit<
+              CreateCalendarEventData,
+              "id" | "createdAt" | "updatedAt"
+            > = {
+              eventName: externalEvent.summary || "Imported Event",
+              eventTime: {
+                start: Timestamp.fromDate(
+                  new Date(
+                    externalEvent.start.dateTime || externalEvent.start.date
+                  )
+                ),
+                end: Timestamp.fromDate(
+                  new Date(externalEvent.end.dateTime || externalEvent.end.date)
+                ),
+              },
+              description: externalEvent.description || "",
+              status: CalendarEventStatus.CONFIRMED,
+              // Set sync status to EXTERNAL as this is imported from an external calendar
+              syncStatus: CalendarSyncStatus.EXTERNAL,
+              eventType: CalendarEventType.BLOCKING, // Use BLOCKING type for external events
+              syncedCalendarEventId: [
+                {
+                  eventId: externalEvent.id,
+                  syncedCalendarProvider: calendar.provider,
+                  syncedAt: currentTime,
+                },
+              ],
+            };
+
+            // Create the event in our system
+            switch (entityType) {
+              case "practitioner":
+                await this.createPractitionerCalendarEvent(entityId, eventData);
+                break;
+              case "patient":
+                await this.createPatientCalendarEvent(entityId, eventData);
+                break;
+              case "clinic":
+                await this.createClinicCalendarEvent(entityId, eventData);
+                break;
+            }
+
+            importedEventsCount++;
+          } catch (eventError) {
+            console.error("Error importing event:", eventError);
+            // Continue with other events even if one fails
+          }
+        }
+      } catch (calendarError) {
+        console.error(
+          `Error fetching events from calendar ${calendar.id}:`,
+          calendarError
+        );
+        // Continue with other calendars even if one fails
+      }
+    }
+
+    return importedEventsCount;
+  }
+
+  /**
+   * Deletes an event from external calendars
+   * @param event - Calendar event to delete
+   * @param entityType - Type of entity (practitioner, patient, clinic)
+   * @param entityId - ID of the entity
+   * @returns Success status
+   */
+  async deleteEventFromExternalCalendars(
+    event: CalendarEvent,
+    entityType: "practitioner" | "patient" | "clinic",
+    entityId: string
+  ): Promise<boolean> {
+    // If the event doesn't have synced calendar event IDs, return success
+    if (
+      !event.syncedCalendarEventId ||
+      event.syncedCalendarEventId.length === 0
+    ) {
+      return true;
+    }
+
+    // Get synced calendars for the entity
+    let syncedCalendars: any[] = [];
+    switch (entityType) {
+      case "practitioner":
+        syncedCalendars =
+          await this.syncedCalendarsService.getPractitionerSyncedCalendars(
+            entityId
+          );
+        break;
+      case "patient":
+        syncedCalendars =
+          await this.syncedCalendarsService.getPatientSyncedCalendars(entityId);
+        break;
+      case "clinic":
+        syncedCalendars =
+          await this.syncedCalendarsService.getClinicSyncedCalendars(entityId);
+        break;
+    }
+
+    // Filter active calendars
+    const activeCalendars = syncedCalendars.filter((cal) => cal.isActive);
+
+    if (activeCalendars.length === 0) {
+      return true;
+    }
+
+    let allSuccessful = true;
+
+    // Delete from each external calendar
+    for (const syncedEvent of event.syncedCalendarEventId) {
+      try {
+        // Find the calendar for this provider
+        const calendar = activeCalendars.find(
+          (cal) => cal.provider === syncedEvent.syncedCalendarProvider
+        );
+
+        if (!calendar) {
+          continue;
+        }
+
+        // Delete based on provider and entity type
+        if (
+          syncedEvent.syncedCalendarProvider === SyncedCalendarProvider.GOOGLE
+        ) {
+          let success = false;
+
+          switch (entityType) {
+            case "practitioner":
+              success =
+                await this.syncedCalendarsService.deletePractitionerGoogleCalendarEvent(
+                  entityId,
+                  calendar.id,
+                  syncedEvent.eventId
+                );
+              break;
+            case "patient":
+              success =
+                await this.syncedCalendarsService.deletePatientGoogleCalendarEvent(
+                  entityId,
+                  calendar.id,
+                  syncedEvent.eventId
+                );
+              break;
+            case "clinic":
+              success =
+                await this.syncedCalendarsService.deleteClinicGoogleCalendarEvent(
+                  entityId,
+                  calendar.id,
+                  syncedEvent.eventId
+                );
+              break;
+          }
+
+          if (!success) {
+            allSuccessful = false;
+          }
+        }
+        // Add other providers as needed
+      } catch (error) {
+        console.error(`Error deleting event from external calendar:`, error);
+        allSuccessful = false;
+      }
+    }
+
+    return allSuccessful;
+  }
+}