@blackcode_sa/metaestetics-api 1.13.3 → 1.13.5

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

@@ -1,313 +1,313 @@
-import { Auth } from "firebase/auth";
-import { Firestore, Timestamp, serverTimestamp } from "firebase/firestore";
-import { FirebaseApp } from "firebase/app";
-import { BaseService } from "../base.service";
-import {
-  CalendarEvent,
-  CalendarEventStatus,
-  CalendarEventTime,
-  CalendarEventType,
-  CalendarSyncStatus,
-  CreateCalendarEventData,
-  UpdateCalendarEventData,
-  CALENDAR_COLLECTION,
-  SearchCalendarEventsParams,
-  SearchLocationEnum,
-  DateRange,
-  CreateBlockingEventParams,
-  UpdateBlockingEventParams,
-} from "../../types/calendar";
-import { PRACTITIONERS_COLLECTION } from "../../types/practitioner";
-import { CLINICS_COLLECTION } from "../../types/clinic";
-import { doc, getDoc, setDoc, updateDoc, deleteDoc } from "firebase/firestore";
-
-// Import utility functions
-import { searchCalendarEventsUtil } from "./utils/calendar-event.utils";
-
-/**
- * Calendar Service V3
- * Focused on blocking event management and calendar event search
- * Appointment logic is handled by AppointmentService and BookingAdmin
- * External calendar sync is handled by dedicated cloud functions
- */
-export class CalendarServiceV3 extends BaseService {
-  /**
-   * Creates a new CalendarServiceV3 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);
-  }
-
-  // #region Blocking Event CRUD Operations
-
-  /**
-   * Creates a blocking event for a practitioner or clinic
-   * @param params - Blocking event creation parameters
-   * @returns Created calendar event
-   */
-  async createBlockingEvent(
-    params: CreateBlockingEventParams
-  ): Promise<CalendarEvent> {
-    // Validate input parameters
-    this.validateBlockingEventParams(params);
-
-    // Generate a unique ID for the event
-    const eventId = this.generateId();
-
-    // Determine the collection path based on entity type
-    const collectionPath = this.getEntityCalendarPath(
-      params.entityType,
-      params.entityId
-    );
-
-    // Create the event document reference
-    const eventRef = doc(this.db, collectionPath, eventId);
-
-    // Prepare the event data
-    const eventData: CreateCalendarEventData = {
-      id: eventId,
-      eventName: params.eventName,
-      eventTime: params.eventTime,
-      eventType: params.eventType,
-      description: params.description || "",
-      status: CalendarEventStatus.CONFIRMED, // Blocking events are always confirmed
-      syncStatus: CalendarSyncStatus.INTERNAL,
-      createdAt: serverTimestamp(),
-      updatedAt: serverTimestamp(),
-    };
-
-    // Set entity-specific fields
-    if (params.entityType === "practitioner") {
-      eventData.practitionerProfileId = params.entityId;
-    } else {
-      eventData.clinicBranchId = params.entityId;
-    }
-
-    // Create the event
-    await setDoc(eventRef, eventData);
-
-    // Return the created event
-    return {
-      ...eventData,
-      createdAt: Timestamp.now(),
-      updatedAt: Timestamp.now(),
-    } as CalendarEvent;
-  }
-
-  /**
-   * Updates a blocking event
-   * @param params - Blocking event update parameters
-   * @returns Updated calendar event
-   */
-  async updateBlockingEvent(
-    params: UpdateBlockingEventParams
-  ): Promise<CalendarEvent> {
-    // Determine the collection path
-    const collectionPath = this.getEntityCalendarPath(
-      params.entityType,
-      params.entityId
-    );
-    const eventRef = doc(this.db, collectionPath, params.eventId);
-
-    // Check if event exists
-    const eventDoc = await getDoc(eventRef);
-    if (!eventDoc.exists()) {
-      throw new Error(`Blocking event with ID ${params.eventId} not found`);
-    }
-
-    // Prepare update data
-    const updateData: Partial<UpdateCalendarEventData> = {
-      updatedAt: serverTimestamp(),
-    };
-
-    if (params.eventName !== undefined) {
-      updateData.eventName = params.eventName;
-    }
-    if (params.eventTime !== undefined) {
-      updateData.eventTime = params.eventTime;
-    }
-    if (params.description !== undefined) {
-      updateData.description = params.description;
-    }
-    if (params.status !== undefined) {
-      updateData.status = params.status;
-    }
-
-    // Update the event
-    await updateDoc(eventRef, updateData);
-
-    // Get and return the updated event
-    const updatedEventDoc = await getDoc(eventRef);
-    return updatedEventDoc.data() as CalendarEvent;
-  }
-
-  /**
-   * Deletes a blocking event
-   * @param entityType - Type of entity (practitioner or clinic)
-   * @param entityId - ID of the entity
-   * @param eventId - ID of the event to delete
-   */
-  async deleteBlockingEvent(
-    entityType: "practitioner" | "clinic",
-    entityId: string,
-    eventId: string
-  ): Promise<void> {
-    // Determine the collection path
-    const collectionPath = this.getEntityCalendarPath(entityType, entityId);
-    const eventRef = doc(this.db, collectionPath, eventId);
-
-    // Check if event exists
-    const eventDoc = await getDoc(eventRef);
-    if (!eventDoc.exists()) {
-      throw new Error(`Blocking event with ID ${eventId} not found`);
-    }
-
-    // Delete the event
-    await deleteDoc(eventRef);
-  }
-
-  /**
-   * Gets a specific blocking event
-   * @param entityType - Type of entity (practitioner or clinic)
-   * @param entityId - ID of the entity
-   * @param eventId - ID of the event to retrieve
-   * @returns Calendar event or null if not found
-   */
-  async getBlockingEvent(
-    entityType: "practitioner" | "clinic",
-    entityId: string,
-    eventId: string
-  ): Promise<CalendarEvent | null> {
-    // Determine the collection path
-    const collectionPath = this.getEntityCalendarPath(entityType, entityId);
-    const eventRef = doc(this.db, collectionPath, eventId);
-
-    // Get the event
-    const eventDoc = await getDoc(eventRef);
-    if (!eventDoc.exists()) {
-      return null;
-    }
-
-    return eventDoc.data() as CalendarEvent;
-  }
-
-  /**
-   * Gets blocking events for a specific entity
-   * @param entityType - Type of entity (practitioner or clinic)
-   * @param entityId - ID of the entity
-   * @param dateRange - Optional date range filter
-   * @param eventType - Optional event type filter
-   * @returns Array of calendar events
-   */
-  async getEntityBlockingEvents(
-    entityType: "practitioner" | "clinic",
-    entityId: string,
-    dateRange?: DateRange,
-    eventType?: CalendarEventType
-  ): Promise<CalendarEvent[]> {
-    // Use the existing search functionality
-    const searchParams: SearchCalendarEventsParams = {
-      searchLocation:
-        entityType === "practitioner"
-          ? SearchLocationEnum.PRACTITIONER
-          : SearchLocationEnum.CLINIC,
-      entityId,
-      dateRange,
-      eventType,
-    };
-
-    // Filter to only blocking-type events if no specific eventType is provided
-    if (!eventType) {
-      // We'll need to filter the results to only include blocking-type events
-      const allEvents = await searchCalendarEventsUtil(this.db, searchParams);
-      return allEvents.filter(
-        (event) =>
-          event.eventType === CalendarEventType.BLOCKING ||
-          event.eventType === CalendarEventType.BREAK ||
-          event.eventType === CalendarEventType.FREE_DAY ||
-          event.eventType === CalendarEventType.OTHER
-      );
-    }
-
-    return searchCalendarEventsUtil(this.db, searchParams);
-  }
-
-  // #endregion
-
-  // #region Calendar Event Search
-
-  /**
-   * Searches for calendar events based on specified criteria.
-   * This method supports searching for ALL event types (appointments, blocking events, etc.)
-   *
-   * @param params - The search parameters
-   * @returns A promise that resolves to an array of matching calendar events
-   */
-  async searchCalendarEvents(
-    params: SearchCalendarEventsParams
-  ): Promise<CalendarEvent[]> {
-    // Use the utility function to perform the search
-    return searchCalendarEventsUtil(this.db, params);
-  }
-
-  // #endregion
-
-  // #region Private Helper Methods
-
-  /**
-   * Gets the calendar collection path for a specific entity
-   * @param entityType - Type of entity (practitioner or clinic)
-   * @param entityId - ID of the entity
-   * @returns Collection path string
-   */
-  private getEntityCalendarPath(
-    entityType: "practitioner" | "clinic",
-    entityId: string
-  ): string {
-    if (entityType === "practitioner") {
-      return `${PRACTITIONERS_COLLECTION}/${entityId}/${CALENDAR_COLLECTION}`;
-    } else {
-      return `${CLINICS_COLLECTION}/${entityId}/${CALENDAR_COLLECTION}`;
-    }
-  }
-
-  /**
-   * Validates blocking event creation parameters
-   * @param params - Parameters to validate
-   * @throws Error if validation fails
-   */
-  private validateBlockingEventParams(params: CreateBlockingEventParams): void {
-    if (!params.entityType || !params.entityId) {
-      throw new Error("Entity type and ID are required");
-    }
-
-    if (!params.eventName || params.eventName.trim() === "") {
-      throw new Error("Event name is required");
-    }
-
-    if (!params.eventTime || !params.eventTime.start || !params.eventTime.end) {
-      throw new Error("Event time with start and end is required");
-    }
-
-    // Validate that end time is after start time
-    if (params.eventTime.end.toMillis() <= params.eventTime.start.toMillis()) {
-      throw new Error("Event end time must be after start time");
-    }
-
-    // Validate event type is one of the blocking types
-    const validTypes = [
-      CalendarEventType.BLOCKING,
-      CalendarEventType.BREAK,
-      CalendarEventType.FREE_DAY,
-      CalendarEventType.OTHER,
-    ];
-    if (!validTypes.includes(params.eventType)) {
-      throw new Error("Invalid event type for blocking events");
-    }
-  }
-
-  // #endregion
-}
+import { Auth } from "firebase/auth";
+import { Firestore, Timestamp, serverTimestamp } from "firebase/firestore";
+import { FirebaseApp } from "firebase/app";
+import { BaseService } from "../base.service";
+import {
+  CalendarEvent,
+  CalendarEventStatus,
+  CalendarEventTime,
+  CalendarEventType,
+  CalendarSyncStatus,
+  CreateCalendarEventData,
+  UpdateCalendarEventData,
+  CALENDAR_COLLECTION,
+  SearchCalendarEventsParams,
+  SearchLocationEnum,
+  DateRange,
+  CreateBlockingEventParams,
+  UpdateBlockingEventParams,
+} from "../../types/calendar";
+import { PRACTITIONERS_COLLECTION } from "../../types/practitioner";
+import { CLINICS_COLLECTION } from "../../types/clinic";
+import { doc, getDoc, setDoc, updateDoc, deleteDoc } from "firebase/firestore";
+
+// Import utility functions
+import { searchCalendarEventsUtil } from "./utils/calendar-event.utils";
+
+/**
+ * Calendar Service V3
+ * Focused on blocking event management and calendar event search
+ * Appointment logic is handled by AppointmentService and BookingAdmin
+ * External calendar sync is handled by dedicated cloud functions
+ */
+export class CalendarServiceV3 extends BaseService {
+  /**
+   * Creates a new CalendarServiceV3 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);
+  }
+
+  // #region Blocking Event CRUD Operations
+
+  /**
+   * Creates a blocking event for a practitioner or clinic
+   * @param params - Blocking event creation parameters
+   * @returns Created calendar event
+   */
+  async createBlockingEvent(
+    params: CreateBlockingEventParams
+  ): Promise<CalendarEvent> {
+    // Validate input parameters
+    this.validateBlockingEventParams(params);
+
+    // Generate a unique ID for the event
+    const eventId = this.generateId();
+
+    // Determine the collection path based on entity type
+    const collectionPath = this.getEntityCalendarPath(
+      params.entityType,
+      params.entityId
+    );
+
+    // Create the event document reference
+    const eventRef = doc(this.db, collectionPath, eventId);
+
+    // Prepare the event data
+    const eventData: CreateCalendarEventData = {
+      id: eventId,
+      eventName: params.eventName,
+      eventTime: params.eventTime,
+      eventType: params.eventType,
+      description: params.description || "",
+      status: CalendarEventStatus.CONFIRMED, // Blocking events are always confirmed
+      syncStatus: CalendarSyncStatus.INTERNAL,
+      createdAt: serverTimestamp(),
+      updatedAt: serverTimestamp(),
+    };
+
+    // Set entity-specific fields
+    if (params.entityType === "practitioner") {
+      eventData.practitionerProfileId = params.entityId;
+    } else {
+      eventData.clinicBranchId = params.entityId;
+    }
+
+    // Create the event
+    await setDoc(eventRef, eventData);
+
+    // Return the created event
+    return {
+      ...eventData,
+      createdAt: Timestamp.now(),
+      updatedAt: Timestamp.now(),
+    } as CalendarEvent;
+  }
+
+  /**
+   * Updates a blocking event
+   * @param params - Blocking event update parameters
+   * @returns Updated calendar event
+   */
+  async updateBlockingEvent(
+    params: UpdateBlockingEventParams
+  ): Promise<CalendarEvent> {
+    // Determine the collection path
+    const collectionPath = this.getEntityCalendarPath(
+      params.entityType,
+      params.entityId
+    );
+    const eventRef = doc(this.db, collectionPath, params.eventId);
+
+    // Check if event exists
+    const eventDoc = await getDoc(eventRef);
+    if (!eventDoc.exists()) {
+      throw new Error(`Blocking event with ID ${params.eventId} not found`);
+    }
+
+    // Prepare update data
+    const updateData: Partial<UpdateCalendarEventData> = {
+      updatedAt: serverTimestamp(),
+    };
+
+    if (params.eventName !== undefined) {
+      updateData.eventName = params.eventName;
+    }
+    if (params.eventTime !== undefined) {
+      updateData.eventTime = params.eventTime;
+    }
+    if (params.description !== undefined) {
+      updateData.description = params.description;
+    }
+    if (params.status !== undefined) {
+      updateData.status = params.status;
+    }
+
+    // Update the event
+    await updateDoc(eventRef, updateData);
+
+    // Get and return the updated event
+    const updatedEventDoc = await getDoc(eventRef);
+    return updatedEventDoc.data() as CalendarEvent;
+  }
+
+  /**
+   * Deletes a blocking event
+   * @param entityType - Type of entity (practitioner or clinic)
+   * @param entityId - ID of the entity
+   * @param eventId - ID of the event to delete
+   */
+  async deleteBlockingEvent(
+    entityType: "practitioner" | "clinic",
+    entityId: string,
+    eventId: string
+  ): Promise<void> {
+    // Determine the collection path
+    const collectionPath = this.getEntityCalendarPath(entityType, entityId);
+    const eventRef = doc(this.db, collectionPath, eventId);
+
+    // Check if event exists
+    const eventDoc = await getDoc(eventRef);
+    if (!eventDoc.exists()) {
+      throw new Error(`Blocking event with ID ${eventId} not found`);
+    }
+
+    // Delete the event
+    await deleteDoc(eventRef);
+  }
+
+  /**
+   * Gets a specific blocking event
+   * @param entityType - Type of entity (practitioner or clinic)
+   * @param entityId - ID of the entity
+   * @param eventId - ID of the event to retrieve
+   * @returns Calendar event or null if not found
+   */
+  async getBlockingEvent(
+    entityType: "practitioner" | "clinic",
+    entityId: string,
+    eventId: string
+  ): Promise<CalendarEvent | null> {
+    // Determine the collection path
+    const collectionPath = this.getEntityCalendarPath(entityType, entityId);
+    const eventRef = doc(this.db, collectionPath, eventId);
+
+    // Get the event
+    const eventDoc = await getDoc(eventRef);
+    if (!eventDoc.exists()) {
+      return null;
+    }
+
+    return eventDoc.data() as CalendarEvent;
+  }
+
+  /**
+   * Gets blocking events for a specific entity
+   * @param entityType - Type of entity (practitioner or clinic)
+   * @param entityId - ID of the entity
+   * @param dateRange - Optional date range filter
+   * @param eventType - Optional event type filter
+   * @returns Array of calendar events
+   */
+  async getEntityBlockingEvents(
+    entityType: "practitioner" | "clinic",
+    entityId: string,
+    dateRange?: DateRange,
+    eventType?: CalendarEventType
+  ): Promise<CalendarEvent[]> {
+    // Use the existing search functionality
+    const searchParams: SearchCalendarEventsParams = {
+      searchLocation:
+        entityType === "practitioner"
+          ? SearchLocationEnum.PRACTITIONER
+          : SearchLocationEnum.CLINIC,
+      entityId,
+      dateRange,
+      eventType,
+    };
+
+    // Filter to only blocking-type events if no specific eventType is provided
+    if (!eventType) {
+      // We'll need to filter the results to only include blocking-type events
+      const allEvents = await searchCalendarEventsUtil(this.db, searchParams);
+      return allEvents.filter(
+        (event) =>
+          event.eventType === CalendarEventType.BLOCKING ||
+          event.eventType === CalendarEventType.BREAK ||
+          event.eventType === CalendarEventType.FREE_DAY ||
+          event.eventType === CalendarEventType.OTHER
+      );
+    }
+
+    return searchCalendarEventsUtil(this.db, searchParams);
+  }
+
+  // #endregion
+
+  // #region Calendar Event Search
+
+  /**
+   * Searches for calendar events based on specified criteria.
+   * This method supports searching for ALL event types (appointments, blocking events, etc.)
+   *
+   * @param params - The search parameters
+   * @returns A promise that resolves to an array of matching calendar events
+   */
+  async searchCalendarEvents(
+    params: SearchCalendarEventsParams
+  ): Promise<CalendarEvent[]> {
+    // Use the utility function to perform the search
+    return searchCalendarEventsUtil(this.db, params);
+  }
+
+  // #endregion
+
+  // #region Private Helper Methods
+
+  /**
+   * Gets the calendar collection path for a specific entity
+   * @param entityType - Type of entity (practitioner or clinic)
+   * @param entityId - ID of the entity
+   * @returns Collection path string
+   */
+  private getEntityCalendarPath(
+    entityType: "practitioner" | "clinic",
+    entityId: string
+  ): string {
+    if (entityType === "practitioner") {
+      return `${PRACTITIONERS_COLLECTION}/${entityId}/${CALENDAR_COLLECTION}`;
+    } else {
+      return `${CLINICS_COLLECTION}/${entityId}/${CALENDAR_COLLECTION}`;
+    }
+  }
+
+  /**
+   * Validates blocking event creation parameters
+   * @param params - Parameters to validate
+   * @throws Error if validation fails
+   */
+  private validateBlockingEventParams(params: CreateBlockingEventParams): void {
+    if (!params.entityType || !params.entityId) {
+      throw new Error("Entity type and ID are required");
+    }
+
+    if (!params.eventName || params.eventName.trim() === "") {
+      throw new Error("Event name is required");
+    }
+
+    if (!params.eventTime || !params.eventTime.start || !params.eventTime.end) {
+      throw new Error("Event time with start and end is required");
+    }
+
+    // Validate that end time is after start time
+    if (params.eventTime.end.toMillis() <= params.eventTime.start.toMillis()) {
+      throw new Error("Event end time must be after start time");
+    }
+
+    // Validate event type is one of the blocking types
+    const validTypes = [
+      CalendarEventType.BLOCKING,
+      CalendarEventType.BREAK,
+      CalendarEventType.FREE_DAY,
+      CalendarEventType.OTHER,
+    ];
+    if (!validTypes.includes(params.eventType)) {
+      throw new Error("Invalid event type for blocking events");
+    }
+  }
+
+  // #endregion
+}