@blackcode_sa/metaestetics-api 1.12.61 → 1.12.62

package/src/services/calendar/utils/practitioner.utils.ts

@@ -1,221 +1,221 @@
-import {
-  Firestore,
-  collection,
-  doc,
-  getDoc,
-  getDocs,
-  setDoc,
-  updateDoc,
-  deleteDoc,
-  query,
-  where,
-  orderBy,
-  Timestamp,
-  serverTimestamp,
-  QueryConstraint,
-} from "firebase/firestore";
-import {
-  CalendarEvent,
-  CalendarEventStatus,
-  CalendarEventType,
-  CreateCalendarEventData,
-  UpdateCalendarEventData,
-  CALENDAR_COLLECTION,
-} from "../../../types/calendar";
-import { getPractitionerCalendarEventDocRef } from "./docs.utils";
-
-/**
- * Creates a calendar event for a practitioner
- * @param db - Firestore instance
- * @param practitionerId - ID of the practitioner
- * @param eventData - Calendar event data
- * @param generateId - Function to generate a unique ID
- * @returns Created calendar event
- */
-export async function createPractitionerCalendarEventUtil(
-  db: Firestore,
-  practitionerId: string,
-  eventData: Omit<CreateCalendarEventData, "id" | "createdAt" | "updatedAt">,
-  generateId: () => string
-): Promise<CalendarEvent> {
-  // TODO: Add validation for event data
-  // - Check if practitioner exists
-  // - Validate event time (start < end)
-  // - Check for overlapping events
-  // - Validate required fields
-
-  const eventId = generateId();
-  const eventRef = getPractitionerCalendarEventDocRef(
-    db,
-    practitionerId,
-    eventId
-  );
-
-  const newEvent: CreateCalendarEventData = {
-    id: eventId,
-    ...eventData,
-    createdAt: serverTimestamp(),
-    updatedAt: serverTimestamp(),
-  };
-
-  await setDoc(eventRef, newEvent);
-
-  // Convert server timestamp to Timestamp for return value
-  return {
-    ...newEvent,
-    createdAt: Timestamp.now(),
-    updatedAt: Timestamp.now(),
-  } as CalendarEvent;
-}
-
-/**
- * Gets a calendar event for a practitioner
- * @param db - Firestore instance
- * @param practitionerId - ID of the practitioner
- * @param eventId - ID of the event
- * @returns Calendar event or null if not found
- */
-export async function getPractitionerCalendarEventUtil(
-  db: Firestore,
-  practitionerId: string,
-  eventId: string
-): Promise<CalendarEvent | null> {
-  const eventRef = getPractitionerCalendarEventDocRef(
-    db,
-    practitionerId,
-    eventId
-  );
-  const eventDoc = await getDoc(eventRef);
-
-  if (!eventDoc.exists()) {
-    return null;
-  }
-
-  return eventDoc.data() as CalendarEvent;
-}
-
-/**
- * Gets calendar events for a practitioner within a date range
- * @param db - Firestore instance
- * @param practitionerId - ID of the practitioner
- * @param startDate - Start date of the range
- * @param endDate - End date of the range
- * @param additionalConstraints - Additional query constraints
- * @returns Array of calendar events
- */
-export async function getPractitionerCalendarEventsUtil(
-  db: Firestore,
-  practitionerId: string,
-  startDate: Date,
-  endDate: Date,
-  additionalConstraints: QueryConstraint[] = []
-): Promise<CalendarEvent[]> {
-  const startTimestamp = Timestamp.fromDate(startDate);
-  const endTimestamp = Timestamp.fromDate(endDate);
-
-  const eventsRef = collection(
-    db,
-    `${CALENDAR_COLLECTION}`,
-    practitionerId,
-    `${CALENDAR_COLLECTION}`
-  );
-
-  const constraints: QueryConstraint[] = [
-    where("eventTime.start", ">=", startTimestamp),
-    where("eventTime.end", "<=", endTimestamp),
-    orderBy("eventTime.start", "asc"),
-    ...additionalConstraints,
-  ];
-
-  const q = query(eventsRef, ...constraints);
-
-  const querySnapshot = await getDocs(q);
-  return querySnapshot.docs.map((doc) => doc.data() as CalendarEvent);
-}
-
-/**
- * Gets confirmed appointments for a practitioner
- * @param db - Firestore instance
- * @param practitionerId - ID of the practitioner
- * @returns Array of confirmed calendar events
- */
-export async function getConfirmedPractitionerAppointmentsUtil(
-  db: Firestore,
-  practitionerId: string
-): Promise<CalendarEvent[]> {
-  const now = new Date();
-  const oneYearFromNow = new Date();
-  oneYearFromNow.setFullYear(oneYearFromNow.getFullYear() + 1);
-
-  return getPractitionerCalendarEventsUtil(
-    db,
-    practitionerId,
-    now,
-    oneYearFromNow,
-    [
-      where("status", "==", CalendarEventStatus.CONFIRMED),
-      where("eventType", "==", CalendarEventType.APPOINTMENT),
-    ]
-  );
-}
-
-/**
- * Updates a calendar event for a practitioner
- * @param db - Firestore instance
- * @param practitionerId - ID of the practitioner
- * @param eventId - ID of the event
- * @param updateData - Data to update
- * @returns Updated calendar event
- */
-export async function updatePractitionerCalendarEventUtil(
-  db: Firestore,
-  practitionerId: string,
-  eventId: string,
-  updateData: Omit<UpdateCalendarEventData, "updatedAt">
-): Promise<CalendarEvent> {
-  // TODO: Add validation for update data
-  // - Check if event exists
-  // - Validate event time (start < end)
-  // - Check for overlapping events
-
-  const eventRef = getPractitionerCalendarEventDocRef(
-    db,
-    practitionerId,
-    eventId
-  );
-
-  const updates: UpdateCalendarEventData = {
-    ...updateData,
-    updatedAt: serverTimestamp(),
-  };
-
-  await updateDoc(eventRef, updates as any);
-
-  // Get the updated document
-  const updatedDoc = await getDoc(eventRef);
-
-  if (!updatedDoc.exists()) {
-    throw new Error("Event not found after update");
-  }
-
-  return updatedDoc.data() as CalendarEvent;
-}
-
-/**
- * Deletes a calendar event for a practitioner
- * @param db - Firestore instance
- * @param practitionerId - ID of the practitioner
- * @param eventId - ID of the event
- */
-export async function deletePractitionerCalendarEventUtil(
-  db: Firestore,
-  practitionerId: string,
-  eventId: string
-): Promise<void> {
-  const eventRef = getPractitionerCalendarEventDocRef(
-    db,
-    practitionerId,
-    eventId
-  );
-  await deleteDoc(eventRef);
-}
+import {
+  Firestore,
+  collection,
+  doc,
+  getDoc,
+  getDocs,
+  setDoc,
+  updateDoc,
+  deleteDoc,
+  query,
+  where,
+  orderBy,
+  Timestamp,
+  serverTimestamp,
+  QueryConstraint,
+} from "firebase/firestore";
+import {
+  CalendarEvent,
+  CalendarEventStatus,
+  CalendarEventType,
+  CreateCalendarEventData,
+  UpdateCalendarEventData,
+  CALENDAR_COLLECTION,
+} from "../../../types/calendar";
+import { getPractitionerCalendarEventDocRef } from "./docs.utils";
+
+/**
+ * Creates a calendar event for a practitioner
+ * @param db - Firestore instance
+ * @param practitionerId - ID of the practitioner
+ * @param eventData - Calendar event data
+ * @param generateId - Function to generate a unique ID
+ * @returns Created calendar event
+ */
+export async function createPractitionerCalendarEventUtil(
+  db: Firestore,
+  practitionerId: string,
+  eventData: Omit<CreateCalendarEventData, "id" | "createdAt" | "updatedAt">,
+  generateId: () => string
+): Promise<CalendarEvent> {
+  // TODO: Add validation for event data
+  // - Check if practitioner exists
+  // - Validate event time (start < end)
+  // - Check for overlapping events
+  // - Validate required fields
+
+  const eventId = generateId();
+  const eventRef = getPractitionerCalendarEventDocRef(
+    db,
+    practitionerId,
+    eventId
+  );
+
+  const newEvent: CreateCalendarEventData = {
+    id: eventId,
+    ...eventData,
+    createdAt: serverTimestamp(),
+    updatedAt: serverTimestamp(),
+  };
+
+  await setDoc(eventRef, newEvent);
+
+  // Convert server timestamp to Timestamp for return value
+  return {
+    ...newEvent,
+    createdAt: Timestamp.now(),
+    updatedAt: Timestamp.now(),
+  } as CalendarEvent;
+}
+
+/**
+ * Gets a calendar event for a practitioner
+ * @param db - Firestore instance
+ * @param practitionerId - ID of the practitioner
+ * @param eventId - ID of the event
+ * @returns Calendar event or null if not found
+ */
+export async function getPractitionerCalendarEventUtil(
+  db: Firestore,
+  practitionerId: string,
+  eventId: string
+): Promise<CalendarEvent | null> {
+  const eventRef = getPractitionerCalendarEventDocRef(
+    db,
+    practitionerId,
+    eventId
+  );
+  const eventDoc = await getDoc(eventRef);
+
+  if (!eventDoc.exists()) {
+    return null;
+  }
+
+  return eventDoc.data() as CalendarEvent;
+}
+
+/**
+ * Gets calendar events for a practitioner within a date range
+ * @param db - Firestore instance
+ * @param practitionerId - ID of the practitioner
+ * @param startDate - Start date of the range
+ * @param endDate - End date of the range
+ * @param additionalConstraints - Additional query constraints
+ * @returns Array of calendar events
+ */
+export async function getPractitionerCalendarEventsUtil(
+  db: Firestore,
+  practitionerId: string,
+  startDate: Date,
+  endDate: Date,
+  additionalConstraints: QueryConstraint[] = []
+): Promise<CalendarEvent[]> {
+  const startTimestamp = Timestamp.fromDate(startDate);
+  const endTimestamp = Timestamp.fromDate(endDate);
+
+  const eventsRef = collection(
+    db,
+    `${CALENDAR_COLLECTION}`,
+    practitionerId,
+    `${CALENDAR_COLLECTION}`
+  );
+
+  const constraints: QueryConstraint[] = [
+    where("eventTime.start", ">=", startTimestamp),
+    where("eventTime.end", "<=", endTimestamp),
+    orderBy("eventTime.start", "asc"),
+    ...additionalConstraints,
+  ];
+
+  const q = query(eventsRef, ...constraints);
+
+  const querySnapshot = await getDocs(q);
+  return querySnapshot.docs.map((doc) => doc.data() as CalendarEvent);
+}
+
+/**
+ * Gets confirmed appointments for a practitioner
+ * @param db - Firestore instance
+ * @param practitionerId - ID of the practitioner
+ * @returns Array of confirmed calendar events
+ */
+export async function getConfirmedPractitionerAppointmentsUtil(
+  db: Firestore,
+  practitionerId: string
+): Promise<CalendarEvent[]> {
+  const now = new Date();
+  const oneYearFromNow = new Date();
+  oneYearFromNow.setFullYear(oneYearFromNow.getFullYear() + 1);
+
+  return getPractitionerCalendarEventsUtil(
+    db,
+    practitionerId,
+    now,
+    oneYearFromNow,
+    [
+      where("status", "==", CalendarEventStatus.CONFIRMED),
+      where("eventType", "==", CalendarEventType.APPOINTMENT),
+    ]
+  );
+}
+
+/**
+ * Updates a calendar event for a practitioner
+ * @param db - Firestore instance
+ * @param practitionerId - ID of the practitioner
+ * @param eventId - ID of the event
+ * @param updateData - Data to update
+ * @returns Updated calendar event
+ */
+export async function updatePractitionerCalendarEventUtil(
+  db: Firestore,
+  practitionerId: string,
+  eventId: string,
+  updateData: Omit<UpdateCalendarEventData, "updatedAt">
+): Promise<CalendarEvent> {
+  // TODO: Add validation for update data
+  // - Check if event exists
+  // - Validate event time (start < end)
+  // - Check for overlapping events
+
+  const eventRef = getPractitionerCalendarEventDocRef(
+    db,
+    practitionerId,
+    eventId
+  );
+
+  const updates: UpdateCalendarEventData = {
+    ...updateData,
+    updatedAt: serverTimestamp(),
+  };
+
+  await updateDoc(eventRef, updates as any);
+
+  // Get the updated document
+  const updatedDoc = await getDoc(eventRef);
+
+  if (!updatedDoc.exists()) {
+    throw new Error("Event not found after update");
+  }
+
+  return updatedDoc.data() as CalendarEvent;
+}
+
+/**
+ * Deletes a calendar event for a practitioner
+ * @param db - Firestore instance
+ * @param practitionerId - ID of the practitioner
+ * @param eventId - ID of the event
+ */
+export async function deletePractitionerCalendarEventUtil(
+  db: Firestore,
+  practitionerId: string,
+  eventId: string
+): Promise<void> {
+  const eventRef = getPractitionerCalendarEventDocRef(
+    db,
+    practitionerId,
+    eventId
+  );
+  await deleteDoc(eventRef);
+}