@blackcode_sa/metaestetics-api 1.4.18 → 1.5.1

package/src/services/calendar/utils/calendar-event.utils.ts

@@ -0,0 +1,510 @@
+import {
+  collection,
+  doc,
+  getDoc,
+  getDocs,
+  setDoc,
+  updateDoc,
+  deleteDoc,
+  query,
+  where,
+  orderBy,
+  Timestamp,
+  serverTimestamp,
+  Firestore,
+  DocumentReference,
+  QueryConstraint,
+} from "firebase/firestore";
+import {
+  CalendarEvent,
+  CalendarEventStatus,
+  CalendarEventTime,
+  CalendarEventType,
+  CalendarSyncStatus,
+  CreateCalendarEventData,
+  UpdateCalendarEventData,
+  CALENDAR_COLLECTION,
+} from "../../../types/calendar";
+import { PRACTITIONERS_COLLECTION } from "../../../types/practitioner";
+import { PATIENTS_COLLECTION } from "../../../types/patient";
+import { CLINICS_COLLECTION } from "../../../types/clinic";
+
+/**
+ * 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 = doc(
+    db,
+    `${PRACTITIONERS_COLLECTION}/${practitionerId}/${CALENDAR_COLLECTION}/${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;
+}
+
+/**
+ * Creates a calendar event for a patient
+ * @param db - Firestore instance
+ * @param patientId - ID of the patient
+ * @param eventData - Calendar event data
+ * @param generateId - Function to generate a unique ID
+ * @returns Created calendar event
+ */
+export async function createPatientCalendarEventUtil(
+  db: Firestore,
+  patientId: string,
+  eventData: Omit<CreateCalendarEventData, "id" | "createdAt" | "updatedAt">,
+  generateId: () => string
+): Promise<CalendarEvent> {
+  // TODO: Add validation for event data
+  // - Check if patient exists
+  // - Validate event time (start < end)
+  // - Check for overlapping events
+  // - Validate required fields
+
+  const eventId = generateId();
+  const eventRef = doc(
+    db,
+    `${PATIENTS_COLLECTION}/${patientId}/${CALENDAR_COLLECTION}/${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;
+}
+
+/**
+ * Creates a calendar event for a clinic
+ * @param db - Firestore instance
+ * @param clinicId - ID of the clinic
+ * @param eventData - Calendar event data
+ * @param generateId - Function to generate a unique ID
+ * @returns Created calendar event
+ */
+export async function createClinicCalendarEventUtil(
+  db: Firestore,
+  clinicId: string,
+  eventData: Omit<CreateCalendarEventData, "id" | "createdAt" | "updatedAt">,
+  generateId: () => string
+): Promise<CalendarEvent> {
+  // TODO: Add validation for event data
+  // - Check if clinic exists
+  // - Validate event time (start < end)
+  // - Check for overlapping events
+  // - Validate required fields
+
+  const eventId = generateId();
+  const eventRef = doc(
+    db,
+    `${CLINICS_COLLECTION}/${clinicId}/${CALENDAR_COLLECTION}/${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 = doc(
+    db,
+    `${PRACTITIONERS_COLLECTION}/${practitionerId}/${CALENDAR_COLLECTION}/${eventId}`
+  );
+  const eventDoc = await getDoc(eventRef);
+
+  if (!eventDoc.exists()) {
+    return null;
+  }
+
+  return eventDoc.data() as CalendarEvent;
+}
+
+/**
+ * Gets a calendar event for a patient
+ * @param db - Firestore instance
+ * @param patientId - ID of the patient
+ * @param eventId - ID of the event
+ * @returns Calendar event or null if not found
+ */
+export async function getPatientCalendarEventUtil(
+  db: Firestore,
+  patientId: string,
+  eventId: string
+): Promise<CalendarEvent | null> {
+  const eventRef = doc(
+    db,
+    `${PATIENTS_COLLECTION}/${patientId}/${CALENDAR_COLLECTION}/${eventId}`
+  );
+  const eventDoc = await getDoc(eventRef);
+
+  if (!eventDoc.exists()) {
+    return null;
+  }
+
+  return eventDoc.data() as CalendarEvent;
+}
+
+/**
+ * Gets a calendar event for a clinic
+ * @param db - Firestore instance
+ * @param clinicId - ID of the clinic
+ * @param eventId - ID of the event
+ * @returns Calendar event or null if not found
+ */
+export async function getClinicCalendarEventUtil(
+  db: Firestore,
+  clinicId: string,
+  eventId: string
+): Promise<CalendarEvent | null> {
+  const eventRef = doc(
+    db,
+    `${CLINICS_COLLECTION}/${clinicId}/${CALENDAR_COLLECTION}/${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
+ * @returns Array of calendar events
+ */
+export async function getPractitionerCalendarEventsUtil(
+  db: Firestore,
+  practitionerId: string,
+  startDate: Date,
+  endDate: Date
+): Promise<CalendarEvent[]> {
+  const startTimestamp = Timestamp.fromDate(startDate);
+  const endTimestamp = Timestamp.fromDate(endDate);
+
+  const eventsRef = collection(
+    db,
+    `${PRACTITIONERS_COLLECTION}/${practitionerId}/${CALENDAR_COLLECTION}`
+  );
+
+  const q = query(
+    eventsRef,
+    where("eventTime.start", ">=", startTimestamp),
+    where("eventTime.end", "<=", endTimestamp),
+    orderBy("eventTime.start", "asc")
+  );
+
+  const querySnapshot = await getDocs(q);
+  return querySnapshot.docs.map((doc) => doc.data() as CalendarEvent);
+}
+
+/**
+ * Gets calendar events for a patient within a date range
+ * @param db - Firestore instance
+ * @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
+ */
+export async function getPatientCalendarEventsUtil(
+  db: Firestore,
+  patientId: string,
+  startDate: Date,
+  endDate: Date
+): Promise<CalendarEvent[]> {
+  const startTimestamp = Timestamp.fromDate(startDate);
+  const endTimestamp = Timestamp.fromDate(endDate);
+
+  const eventsRef = collection(
+    db,
+    `${PATIENTS_COLLECTION}/${patientId}/${CALENDAR_COLLECTION}`
+  );
+
+  const q = query(
+    eventsRef,
+    where("eventTime.start", ">=", startTimestamp),
+    where("eventTime.end", "<=", endTimestamp),
+    orderBy("eventTime.start", "asc")
+  );
+
+  const querySnapshot = await getDocs(q);
+  return querySnapshot.docs.map((doc) => doc.data() as CalendarEvent);
+}
+
+/**
+ * Gets calendar events for a clinic within a date range
+ * @param db - Firestore instance
+ * @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
+ */
+export async function getClinicCalendarEventsUtil(
+  db: Firestore,
+  clinicId: string,
+  startDate: Date,
+  endDate: Date
+): Promise<CalendarEvent[]> {
+  const startTimestamp = Timestamp.fromDate(startDate);
+  const endTimestamp = Timestamp.fromDate(endDate);
+
+  const eventsRef = collection(
+    db,
+    `${CLINICS_COLLECTION}/${clinicId}/${CALENDAR_COLLECTION}`
+  );
+
+  const q = query(
+    eventsRef,
+    where("eventTime.start", ">=", startTimestamp),
+    where("eventTime.end", "<=", endTimestamp),
+    orderBy("eventTime.start", "asc")
+  );
+
+  const querySnapshot = await getDocs(q);
+  return querySnapshot.docs.map((doc) => doc.data() as CalendarEvent);
+}
+
+/**
+ * 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 = doc(
+    db,
+    `${PRACTITIONERS_COLLECTION}/${practitionerId}/${CALENDAR_COLLECTION}/${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;
+}
+
+/**
+ * Updates a calendar event for a patient
+ * @param db - Firestore instance
+ * @param patientId - ID of the patient
+ * @param eventId - ID of the event
+ * @param updateData - Data to update
+ * @returns Updated calendar event
+ */
+export async function updatePatientCalendarEventUtil(
+  db: Firestore,
+  patientId: 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 = doc(
+    db,
+    `${PATIENTS_COLLECTION}/${patientId}/${CALENDAR_COLLECTION}/${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;
+}
+
+/**
+ * Updates a calendar event for a clinic
+ * @param db - Firestore instance
+ * @param clinicId - ID of the clinic
+ * @param eventId - ID of the event
+ * @param updateData - Data to update
+ * @returns Updated calendar event
+ */
+export async function updateClinicCalendarEventUtil(
+  db: Firestore,
+  clinicId: 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 = doc(
+    db,
+    `${CLINICS_COLLECTION}/${clinicId}/${CALENDAR_COLLECTION}/${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 = doc(
+    db,
+    `${PRACTITIONERS_COLLECTION}/${practitionerId}/${CALENDAR_COLLECTION}/${eventId}`
+  );
+  await deleteDoc(eventRef);
+}
+
+/**
+ * Deletes a calendar event for a patient
+ * @param db - Firestore instance
+ * @param patientId - ID of the patient
+ * @param eventId - ID of the event
+ */
+export async function deletePatientCalendarEventUtil(
+  db: Firestore,
+  patientId: string,
+  eventId: string
+): Promise<void> {
+  const eventRef = doc(
+    db,
+    `${PATIENTS_COLLECTION}/${patientId}/${CALENDAR_COLLECTION}/${eventId}`
+  );
+  await deleteDoc(eventRef);
+}
+
+/**
+ * Deletes a calendar event for a clinic
+ * @param db - Firestore instance
+ * @param clinicId - ID of the clinic
+ * @param eventId - ID of the event
+ */
+export async function deleteClinicCalendarEventUtil(
+  db: Firestore,
+  clinicId: string,
+  eventId: string
+): Promise<void> {
+  const eventRef = doc(
+    db,
+    `${CLINICS_COLLECTION}/${clinicId}/${CALENDAR_COLLECTION}/${eventId}`
+  );
+  await deleteDoc(eventRef);
+}