@blackcode_sa/metaestetics-api 1.4.18 → 1.5.1

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

@@ -0,0 +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
+}

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

@@ -0,0 +1,157 @@
+import { Firestore, doc, DocumentReference } from "firebase/firestore";
+import { CALENDAR_COLLECTION } from "../../../types/calendar";
+import { PRACTITIONERS_COLLECTION } from "../../../types/practitioner";
+import { PATIENTS_COLLECTION } from "../../../types/patient";
+import { CLINICS_COLLECTION } from "../../../types/clinic";
+
+/**
+ * Gets a reference to a practitioner's calendar event document
+ * @param db - Firestore instance
+ * @param practitionerId - ID of the practitioner
+ * @param eventId - ID of the event
+ * @returns DocumentReference to the calendar event
+ */
+export function getPractitionerCalendarEventDocRef(
+  db: Firestore,
+  practitionerId: string,
+  eventId: string
+): DocumentReference {
+  return doc(
+    db,
+    `${PRACTITIONERS_COLLECTION}/${practitionerId}/${CALENDAR_COLLECTION}/${eventId}`
+  );
+}
+
+/**
+ * Gets a reference to a practitioner's calendar collection
+ * @param db - Firestore instance
+ * @param practitionerId - ID of the practitioner
+ * @returns DocumentReference to the calendar collection
+ */
+export function getPractitionerCalendarCollectionRef(
+  db: Firestore,
+  practitionerId: string
+): DocumentReference {
+  return doc(
+    db,
+    `${PRACTITIONERS_COLLECTION}/${practitionerId}/${CALENDAR_COLLECTION}`
+  );
+}
+
+/**
+ * Gets a reference to a patient's calendar event document
+ * @param db - Firestore instance
+ * @param patientId - ID of the patient
+ * @param eventId - ID of the event
+ * @returns DocumentReference to the calendar event
+ */
+export function getPatientCalendarEventDocRef(
+  db: Firestore,
+  patientId: string,
+  eventId: string
+): DocumentReference {
+  return doc(
+    db,
+    `${PATIENTS_COLLECTION}/${patientId}/${CALENDAR_COLLECTION}/${eventId}`
+  );
+}
+
+/**
+ * Gets a reference to a patient's calendar collection
+ * @param db - Firestore instance
+ * @param patientId - ID of the patient
+ * @returns DocumentReference to the calendar collection
+ */
+export function getPatientCalendarCollectionRef(
+  db: Firestore,
+  patientId: string
+): DocumentReference {
+  return doc(db, `${PATIENTS_COLLECTION}/${patientId}/${CALENDAR_COLLECTION}`);
+}
+
+/**
+ * Gets a reference to a clinic's calendar event document
+ * @param db - Firestore instance
+ * @param clinicId - ID of the clinic
+ * @param eventId - ID of the event
+ * @returns DocumentReference to the calendar event
+ */
+export function getClinicCalendarEventDocRef(
+  db: Firestore,
+  clinicId: string,
+  eventId: string
+): DocumentReference {
+  return doc(
+    db,
+    `${CLINICS_COLLECTION}/${clinicId}/${CALENDAR_COLLECTION}/${eventId}`
+  );
+}
+
+/**
+ * Gets a reference to a clinic's calendar collection
+ * @param db - Firestore instance
+ * @param clinicId - ID of the clinic
+ * @returns DocumentReference to the calendar collection
+ */
+export function getClinicCalendarCollectionRef(
+  db: Firestore,
+  clinicId: string
+): DocumentReference {
+  return doc(db, `${CLINICS_COLLECTION}/${clinicId}/${CALENDAR_COLLECTION}`);
+}
+
+// Synced Calendar References
+
+/**
+ * Gets a reference to a practitioner's synced calendar event document
+ * @param db - Firestore instance
+ * @param practitionerId - ID of the practitioner
+ * @param syncedCalendarId - ID of the synced calendar
+ * @returns DocumentReference to the synced calendar event
+ */
+export function getPractitionerSyncedCalendarDocRef(
+  db: Firestore,
+  practitionerId: string,
+  syncedCalendarId: string
+): DocumentReference {
+  return doc(
+    db,
+    `${PRACTITIONERS_COLLECTION}/${practitionerId}/syncedCalendars/${syncedCalendarId}`
+  );
+}
+
+/**
+ * Gets a reference to a patient's synced calendar event document
+ * @param db - Firestore instance
+ * @param patientId - ID of the patient
+ * @param syncedCalendarId - ID of the synced calendar
+ * @returns DocumentReference to the synced calendar event
+ */
+export function getPatientSyncedCalendarDocRef(
+  db: Firestore,
+  patientId: string,
+  syncedCalendarId: string
+): DocumentReference {
+  return doc(
+    db,
+    `${PATIENTS_COLLECTION}/${patientId}/syncedCalendars/${syncedCalendarId}`
+  );
+}
+
+/**
+ * Gets a reference to a clinic's synced calendar event document
+ * @param db - Firestore instance
+ * @param clinicId - ID of the clinic
+ * @param syncedCalendarId - ID of the synced calendar
+ * @returns DocumentReference to the synced calendar event
+ */
+export function getClinicSyncedCalendarDocRef(
+  db: Firestore,
+  clinicId: string,
+  syncedCalendarId: string
+): DocumentReference {
+  return doc(
+    db,
+    `${CLINICS_COLLECTION}/${clinicId}/syncedCalendars/${syncedCalendarId}`
+  );
+}