@blackcode_sa/metaestetics-api 1.12.62 → 1.12.64

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

@@ -1,237 +1,237 @@
-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 { getClinicCalendarEventDocRef } from "./docs.utils";
-import { CLINIC_GROUPS_COLLECTION } from "../../../types/clinic";
-
-/**
- * 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 = getClinicCalendarEventDocRef(db, clinicId, 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 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 = getClinicCalendarEventDocRef(db, clinicId, eventId);
-  const eventDoc = await getDoc(eventRef);
-
-  if (!eventDoc.exists()) {
-    return null;
-  }
-
-  return eventDoc.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
- * @param additionalConstraints - Additional query constraints
- * @returns Array of calendar events
- */
-export async function getClinicCalendarEventsUtil(
-  db: Firestore,
-  clinicId: 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}`,
-    clinicId,
-    `${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 pending appointments for a clinic
- * @param db - Firestore instance
- * @param clinicId - ID of the clinic
- * @returns Array of pending calendar events
- */
-export async function getPendingClinicAppointmentsUtil(
-  db: Firestore,
-  clinicId: string
-): Promise<CalendarEvent[]> {
-  const now = new Date();
-  const oneYearFromNow = new Date();
-  oneYearFromNow.setFullYear(oneYearFromNow.getFullYear() + 1);
-
-  return getClinicCalendarEventsUtil(db, clinicId, now, oneYearFromNow, [
-    where("status", "==", CalendarEventStatus.PENDING),
-    where("eventType", "==", CalendarEventType.APPOINTMENT),
-  ]);
-}
-
-/**
- * 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 = getClinicCalendarEventDocRef(db, clinicId, 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 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 = getClinicCalendarEventDocRef(db, clinicId, eventId);
-  await deleteDoc(eventRef);
-}
-
-/**
- * Checks if a clinic group has automatic appointment confirmation enabled
- * @param db - Firestore instance
- * @param clinicId - ID of the clinic
- * @returns Boolean indicating if automatic confirmation is enabled
- */
-export async function checkAutoConfirmAppointmentsUtil(
-  db: Firestore,
-  clinicId: string
-): Promise<boolean> {
-  // First, get the clinic to find its clinic group
-  const clinicDoc = await getDoc(doc(db, `clinics/${clinicId}`));
-
-  if (!clinicDoc.exists()) {
-    throw new Error(`Clinic with ID ${clinicId} not found`);
-  }
-
-  const clinicData = clinicDoc.data();
-  const clinicGroupId = clinicData.clinicGroupId;
-
-  if (!clinicGroupId) {
-    return false; // Default to false if no clinic group is associated
-  }
-
-  // Get the clinic group settings
-  const clinicGroupDoc = await getDoc(
-    doc(db, `${CLINIC_GROUPS_COLLECTION}/${clinicGroupId}`)
-  );
-
-  if (!clinicGroupDoc.exists()) {
-    return false; // Default to false if clinic group doesn't exist
-  }
-
-  const clinicGroupData = clinicGroupDoc.data();
-  return !!clinicGroupData.autoConfirmAppointments; // Convert to boolean
-}
+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 { getClinicCalendarEventDocRef } from "./docs.utils";
+import { CLINIC_GROUPS_COLLECTION } from "../../../types/clinic";
+
+/**
+ * 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 = getClinicCalendarEventDocRef(db, clinicId, 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 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 = getClinicCalendarEventDocRef(db, clinicId, eventId);
+  const eventDoc = await getDoc(eventRef);
+
+  if (!eventDoc.exists()) {
+    return null;
+  }
+
+  return eventDoc.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
+ * @param additionalConstraints - Additional query constraints
+ * @returns Array of calendar events
+ */
+export async function getClinicCalendarEventsUtil(
+  db: Firestore,
+  clinicId: 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}`,
+    clinicId,
+    `${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 pending appointments for a clinic
+ * @param db - Firestore instance
+ * @param clinicId - ID of the clinic
+ * @returns Array of pending calendar events
+ */
+export async function getPendingClinicAppointmentsUtil(
+  db: Firestore,
+  clinicId: string
+): Promise<CalendarEvent[]> {
+  const now = new Date();
+  const oneYearFromNow = new Date();
+  oneYearFromNow.setFullYear(oneYearFromNow.getFullYear() + 1);
+
+  return getClinicCalendarEventsUtil(db, clinicId, now, oneYearFromNow, [
+    where("status", "==", CalendarEventStatus.PENDING),
+    where("eventType", "==", CalendarEventType.APPOINTMENT),
+  ]);
+}
+
+/**
+ * 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 = getClinicCalendarEventDocRef(db, clinicId, 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 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 = getClinicCalendarEventDocRef(db, clinicId, eventId);
+  await deleteDoc(eventRef);
+}
+
+/**
+ * Checks if a clinic group has automatic appointment confirmation enabled
+ * @param db - Firestore instance
+ * @param clinicId - ID of the clinic
+ * @returns Boolean indicating if automatic confirmation is enabled
+ */
+export async function checkAutoConfirmAppointmentsUtil(
+  db: Firestore,
+  clinicId: string
+): Promise<boolean> {
+  // First, get the clinic to find its clinic group
+  const clinicDoc = await getDoc(doc(db, `clinics/${clinicId}`));
+
+  if (!clinicDoc.exists()) {
+    throw new Error(`Clinic with ID ${clinicId} not found`);
+  }
+
+  const clinicData = clinicDoc.data();
+  const clinicGroupId = clinicData.clinicGroupId;
+
+  if (!clinicGroupId) {
+    return false; // Default to false if no clinic group is associated
+  }
+
+  // Get the clinic group settings
+  const clinicGroupDoc = await getDoc(
+    doc(db, `${CLINIC_GROUPS_COLLECTION}/${clinicGroupId}`)
+  );
+
+  if (!clinicGroupDoc.exists()) {
+    return false; // Default to false if clinic group doesn't exist
+  }
+
+  const clinicGroupData = clinicGroupDoc.data();
+  return !!clinicGroupData.autoConfirmAppointments; // Convert to boolean
+}