@blackcode_sa/metaestetics-api 1.12.61 → 1.12.62

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

@@ -1,260 +1,260 @@
-import {
-  collection,
-  query,
-  where,
-  getDocs,
-  Firestore,
-  limit,
-  startAfter,
-  doc,
-  getDoc,
-  QueryConstraint,
-} from "firebase/firestore";
-import {
-  PatientProfile,
-  PatientSensitiveInfo,
-  PatientProfileForDoctor,
-  PATIENTS_COLLECTION,
-} from "../../../types/patient";
-import { getSensitiveInfoDocRef } from "./docs.utils";
-import {
-  Practitioner,
-  PRACTITIONERS_COLLECTION,
-} from "../../../types/practitioner";
-
-/**
- * Retrieves all patients associated with a specific practitioner with pagination support.
- *
- * @param {Firestore} db - Firestore instance
- * @param {string} practitionerId - ID of the practitioner whose patients to retrieve
- * @param {Object} options - Optional parameters for pagination
- * @param {number} options.limit - Maximum number of profiles to return
- * @param {string} options.startAfter - The ID of the document to start after (for pagination)
- * @returns {Promise<PatientProfile[]>} A promise resolving to an array of patient profiles
- */
-export const getPatientsByPractitionerUtil = async (
-  db: Firestore,
-  practitionerId: string,
-  options?: { limit?: number; startAfter?: string }
-): Promise<PatientProfile[]> => {
-  try {
-    console.log(
-      `[getPatientsByPractitionerUtil] Fetching patients for practitioner ID: ${practitionerId} with options:`,
-      options
-    );
-
-    const patientsCollection = collection(db, PATIENTS_COLLECTION);
-    const constraints: QueryConstraint[] = [
-      where("doctorIds", "array-contains", practitionerId),
-    ];
-
-    let q = query(patientsCollection, ...constraints);
-
-    // Apply pagination if needed
-    if (options?.limit) {
-      q = query(q, limit(options.limit));
-    }
-
-    // If startAfter is provided, get that document and use it for pagination
-    if (options?.startAfter) {
-      const startAfterDoc = await getDoc(
-        doc(db, PATIENTS_COLLECTION, options.startAfter)
-      );
-      if (startAfterDoc.exists()) {
-        q = query(q, startAfter(startAfterDoc));
-      }
-    }
-
-    const patientsSnapshot = await getDocs(q);
-
-    const patients: PatientProfile[] = [];
-    patientsSnapshot.forEach((doc) => {
-      patients.push(doc.data() as PatientProfile);
-    });
-
-    console.log(
-      `[getPatientsByPractitionerUtil] Found ${patients.length} patients for practitioner ID: ${practitionerId}`
-    );
-    return patients;
-  } catch (error) {
-    console.error(
-      `[getPatientsByPractitionerUtil] Error fetching patients for practitioner:`,
-      error
-    );
-    throw new Error(
-      `Failed to retrieve patients for practitioner: ${
-        error instanceof Error ? error.message : String(error)
-      }`
-    );
-  }
-};
-
-/**
- * Retrieves all patients associated with a specific practitioner with their sensitive information.
- *
- * @param {Firestore} db - Firestore instance
- * @param {string} practitionerId - ID of the practitioner whose patients to retrieve
- * @param {Object} options - Optional parameters for pagination
- * @param {number} options.limit - Maximum number of profiles to return
- * @param {string} options.startAfter - The ID of the document to start after (for pagination)
- * @returns {Promise<PatientProfileForDoctor[]>} A promise resolving to an array of patient profiles with sensitive info
- */
-export const getPatientsByPractitionerWithDetailsUtil = async (
-  db: Firestore,
-  practitionerId: string,
-  options?: { limit?: number; startAfter?: string }
-): Promise<PatientProfileForDoctor[]> => {
-  try {
-    console.log(
-      `[getPatientsByPractitionerWithDetailsUtil] Fetching detailed patient profiles for practitioner ID: ${practitionerId} with options:`,
-      options
-    );
-
-    // First, get all patient profiles for this practitioner
-    const patientProfiles = await getPatientsByPractitionerUtil(
-      db,
-      practitionerId,
-      options
-    );
-
-    // Then, fetch sensitive info for each patient
-    const patientProfilesWithDetails: PatientProfileForDoctor[] =
-      await Promise.all(
-        patientProfiles.map(async (profile) => {
-          try {
-            const sensitiveInfoDoc = await getDoc(
-              getSensitiveInfoDocRef(db, profile.id)
-            );
-            const sensitiveInfo = sensitiveInfoDoc.exists()
-              ? (sensitiveInfoDoc.data() as PatientSensitiveInfo)
-              : undefined;
-
-            return {
-              patientProfile: profile,
-              patientSensitiveInfo: sensitiveInfo,
-            };
-          } catch (error) {
-            console.error(
-              `[getPatientsByPractitionerWithDetailsUtil] Error fetching sensitive info for patient ${profile.id}:`,
-              error
-            );
-            // Return profile without sensitive info in case of error
-            return { patientProfile: profile };
-          }
-        })
-      );
-
-    console.log(
-      `[getPatientsByPractitionerWithDetailsUtil] Found ${patientProfilesWithDetails.length} detailed patient profiles for practitioner ID: ${practitionerId}`
-    );
-    return patientProfilesWithDetails;
-  } catch (error) {
-    console.error(
-      `[getPatientsByPractitionerWithDetailsUtil] Error fetching detailed patient profiles:`,
-      error
-    );
-    throw new Error(
-      `Failed to retrieve detailed patient profiles: ${
-        error instanceof Error ? error.message : String(error)
-      }`
-    );
-  }
-};
-
-/**
- * Retrieves a practitioner profile by ID
- *
- * @param {Firestore} db - Firestore instance
- * @param {string} practitionerId - ID of the practitioner to retrieve
- * @returns {Promise<Practitioner | null>} A promise resolving to the practitioner profile or null if not found
- */
-export const getPractitionerProfile = async (
-  db: Firestore,
-  practitionerId: string
-): Promise<Practitioner | null> => {
-  try {
-    console.log(
-      `[getPractitionerProfile] Fetching practitioner with ID: ${practitionerId}`
-    );
-
-    const practitionerRef = doc(db, PRACTITIONERS_COLLECTION, practitionerId);
-    const practitionerSnapshot = await getDoc(practitionerRef);
-
-    if (!practitionerSnapshot.exists()) {
-      console.log(
-        `[getPractitionerProfile] Practitioner with ID ${practitionerId} not found`
-      );
-      return null;
-    }
-
-    const practitioner = practitionerSnapshot.data() as Practitioner;
-    console.log(
-      `[getPractitionerProfile] Successfully retrieved practitioner: ${practitioner.basicInfo.firstName} ${practitioner.basicInfo.lastName}`
-    );
-
-    return practitioner;
-  } catch (error) {
-    console.error(
-      `[getPractitionerProfile] Error fetching practitioner:`,
-      error
-    );
-    throw new Error(
-      `Failed to retrieve practitioner: ${
-        error instanceof Error ? error.message : String(error)
-      }`
-    );
-  }
-};
-
-/**
- * Retrieves a practitioner profile by user reference ID
- *
- * @param {Firestore} db - Firestore instance
- * @param {string} userRef - Firebase Auth user ID reference
- * @returns {Promise<Practitioner | null>} A promise resolving to the practitioner profile or null if not found
- */
-export const getPractitionerProfileByUserRef = async (
-  db: Firestore,
-  userRef: string
-): Promise<Practitioner | null> => {
-  try {
-    console.log(
-      `[getPractitionerProfileByUserRef] Fetching practitioner with userRef: ${userRef}`
-    );
-
-    const practitionersCollection = collection(db, PRACTITIONERS_COLLECTION);
-    const q = query(
-      practitionersCollection,
-      where("userRef", "==", userRef),
-      limit(1)
-    );
-
-    const querySnapshot = await getDocs(q);
-
-    if (querySnapshot.empty) {
-      console.log(
-        `[getPractitionerProfileByUserRef] No practitioner found with userRef: ${userRef}`
-      );
-      return null;
-    }
-
-    const practitionerDoc = querySnapshot.docs[0];
-    const practitioner = practitionerDoc.data() as Practitioner;
-
-    console.log(
-      `[getPractitionerProfileByUserRef] Successfully retrieved practitioner: ${practitioner.basicInfo.firstName} ${practitioner.basicInfo.lastName}`
-    );
-
-    return practitioner;
-  } catch (error) {
-    console.error(
-      `[getPractitionerProfileByUserRef] Error fetching practitioner:`,
-      error
-    );
-    throw new Error(
-      `Failed to retrieve practitioner by userRef: ${
-        error instanceof Error ? error.message : String(error)
-      }`
-    );
-  }
-};
+import {
+  collection,
+  query,
+  where,
+  getDocs,
+  Firestore,
+  limit,
+  startAfter,
+  doc,
+  getDoc,
+  QueryConstraint,
+} from "firebase/firestore";
+import {
+  PatientProfile,
+  PatientSensitiveInfo,
+  PatientProfileForDoctor,
+  PATIENTS_COLLECTION,
+} from "../../../types/patient";
+import { getSensitiveInfoDocRef } from "./docs.utils";
+import {
+  Practitioner,
+  PRACTITIONERS_COLLECTION,
+} from "../../../types/practitioner";
+
+/**
+ * Retrieves all patients associated with a specific practitioner with pagination support.
+ *
+ * @param {Firestore} db - Firestore instance
+ * @param {string} practitionerId - ID of the practitioner whose patients to retrieve
+ * @param {Object} options - Optional parameters for pagination
+ * @param {number} options.limit - Maximum number of profiles to return
+ * @param {string} options.startAfter - The ID of the document to start after (for pagination)
+ * @returns {Promise<PatientProfile[]>} A promise resolving to an array of patient profiles
+ */
+export const getPatientsByPractitionerUtil = async (
+  db: Firestore,
+  practitionerId: string,
+  options?: { limit?: number; startAfter?: string }
+): Promise<PatientProfile[]> => {
+  try {
+    console.log(
+      `[getPatientsByPractitionerUtil] Fetching patients for practitioner ID: ${practitionerId} with options:`,
+      options
+    );
+
+    const patientsCollection = collection(db, PATIENTS_COLLECTION);
+    const constraints: QueryConstraint[] = [
+      where("doctorIds", "array-contains", practitionerId),
+    ];
+
+    let q = query(patientsCollection, ...constraints);
+
+    // Apply pagination if needed
+    if (options?.limit) {
+      q = query(q, limit(options.limit));
+    }
+
+    // If startAfter is provided, get that document and use it for pagination
+    if (options?.startAfter) {
+      const startAfterDoc = await getDoc(
+        doc(db, PATIENTS_COLLECTION, options.startAfter)
+      );
+      if (startAfterDoc.exists()) {
+        q = query(q, startAfter(startAfterDoc));
+      }
+    }
+
+    const patientsSnapshot = await getDocs(q);
+
+    const patients: PatientProfile[] = [];
+    patientsSnapshot.forEach((doc) => {
+      patients.push(doc.data() as PatientProfile);
+    });
+
+    console.log(
+      `[getPatientsByPractitionerUtil] Found ${patients.length} patients for practitioner ID: ${practitionerId}`
+    );
+    return patients;
+  } catch (error) {
+    console.error(
+      `[getPatientsByPractitionerUtil] Error fetching patients for practitioner:`,
+      error
+    );
+    throw new Error(
+      `Failed to retrieve patients for practitioner: ${
+        error instanceof Error ? error.message : String(error)
+      }`
+    );
+  }
+};
+
+/**
+ * Retrieves all patients associated with a specific practitioner with their sensitive information.
+ *
+ * @param {Firestore} db - Firestore instance
+ * @param {string} practitionerId - ID of the practitioner whose patients to retrieve
+ * @param {Object} options - Optional parameters for pagination
+ * @param {number} options.limit - Maximum number of profiles to return
+ * @param {string} options.startAfter - The ID of the document to start after (for pagination)
+ * @returns {Promise<PatientProfileForDoctor[]>} A promise resolving to an array of patient profiles with sensitive info
+ */
+export const getPatientsByPractitionerWithDetailsUtil = async (
+  db: Firestore,
+  practitionerId: string,
+  options?: { limit?: number; startAfter?: string }
+): Promise<PatientProfileForDoctor[]> => {
+  try {
+    console.log(
+      `[getPatientsByPractitionerWithDetailsUtil] Fetching detailed patient profiles for practitioner ID: ${practitionerId} with options:`,
+      options
+    );
+
+    // First, get all patient profiles for this practitioner
+    const patientProfiles = await getPatientsByPractitionerUtil(
+      db,
+      practitionerId,
+      options
+    );
+
+    // Then, fetch sensitive info for each patient
+    const patientProfilesWithDetails: PatientProfileForDoctor[] =
+      await Promise.all(
+        patientProfiles.map(async (profile) => {
+          try {
+            const sensitiveInfoDoc = await getDoc(
+              getSensitiveInfoDocRef(db, profile.id)
+            );
+            const sensitiveInfo = sensitiveInfoDoc.exists()
+              ? (sensitiveInfoDoc.data() as PatientSensitiveInfo)
+              : undefined;
+
+            return {
+              patientProfile: profile,
+              patientSensitiveInfo: sensitiveInfo,
+            };
+          } catch (error) {
+            console.error(
+              `[getPatientsByPractitionerWithDetailsUtil] Error fetching sensitive info for patient ${profile.id}:`,
+              error
+            );
+            // Return profile without sensitive info in case of error
+            return { patientProfile: profile };
+          }
+        })
+      );
+
+    console.log(
+      `[getPatientsByPractitionerWithDetailsUtil] Found ${patientProfilesWithDetails.length} detailed patient profiles for practitioner ID: ${practitionerId}`
+    );
+    return patientProfilesWithDetails;
+  } catch (error) {
+    console.error(
+      `[getPatientsByPractitionerWithDetailsUtil] Error fetching detailed patient profiles:`,
+      error
+    );
+    throw new Error(
+      `Failed to retrieve detailed patient profiles: ${
+        error instanceof Error ? error.message : String(error)
+      }`
+    );
+  }
+};
+
+/**
+ * Retrieves a practitioner profile by ID
+ *
+ * @param {Firestore} db - Firestore instance
+ * @param {string} practitionerId - ID of the practitioner to retrieve
+ * @returns {Promise<Practitioner | null>} A promise resolving to the practitioner profile or null if not found
+ */
+export const getPractitionerProfile = async (
+  db: Firestore,
+  practitionerId: string
+): Promise<Practitioner | null> => {
+  try {
+    console.log(
+      `[getPractitionerProfile] Fetching practitioner with ID: ${practitionerId}`
+    );
+
+    const practitionerRef = doc(db, PRACTITIONERS_COLLECTION, practitionerId);
+    const practitionerSnapshot = await getDoc(practitionerRef);
+
+    if (!practitionerSnapshot.exists()) {
+      console.log(
+        `[getPractitionerProfile] Practitioner with ID ${practitionerId} not found`
+      );
+      return null;
+    }
+
+    const practitioner = practitionerSnapshot.data() as Practitioner;
+    console.log(
+      `[getPractitionerProfile] Successfully retrieved practitioner: ${practitioner.basicInfo.firstName} ${practitioner.basicInfo.lastName}`
+    );
+
+    return practitioner;
+  } catch (error) {
+    console.error(
+      `[getPractitionerProfile] Error fetching practitioner:`,
+      error
+    );
+    throw new Error(
+      `Failed to retrieve practitioner: ${
+        error instanceof Error ? error.message : String(error)
+      }`
+    );
+  }
+};
+
+/**
+ * Retrieves a practitioner profile by user reference ID
+ *
+ * @param {Firestore} db - Firestore instance
+ * @param {string} userRef - Firebase Auth user ID reference
+ * @returns {Promise<Practitioner | null>} A promise resolving to the practitioner profile or null if not found
+ */
+export const getPractitionerProfileByUserRef = async (
+  db: Firestore,
+  userRef: string
+): Promise<Practitioner | null> => {
+  try {
+    console.log(
+      `[getPractitionerProfileByUserRef] Fetching practitioner with userRef: ${userRef}`
+    );
+
+    const practitionersCollection = collection(db, PRACTITIONERS_COLLECTION);
+    const q = query(
+      practitionersCollection,
+      where("userRef", "==", userRef),
+      limit(1)
+    );
+
+    const querySnapshot = await getDocs(q);
+
+    if (querySnapshot.empty) {
+      console.log(
+        `[getPractitionerProfileByUserRef] No practitioner found with userRef: ${userRef}`
+      );
+      return null;
+    }
+
+    const practitionerDoc = querySnapshot.docs[0];
+    const practitioner = practitionerDoc.data() as Practitioner;
+
+    console.log(
+      `[getPractitionerProfileByUserRef] Successfully retrieved practitioner: ${practitioner.basicInfo.firstName} ${practitioner.basicInfo.lastName}`
+    );
+
+    return practitioner;
+  } catch (error) {
+    console.error(
+      `[getPractitionerProfileByUserRef] Error fetching practitioner:`,
+      error
+    );
+    throw new Error(
+      `Failed to retrieve practitioner by userRef: ${
+        error instanceof Error ? error.message : String(error)
+      }`
+    );
+  }
+};