@blackcode_sa/metaestetics-api 1.5.43 → 1.5.45

package/src/services/patient/patient.service.ts

@@ -5,8 +5,8 @@ import {
   updateDoc,
   arrayUnion,
   serverTimestamp,
-} from 'firebase/firestore';
-import { BaseService } from '../base.service';
+} from "firebase/firestore";
+import { BaseService } from "../base.service";
 import {
   PatientProfile,
   PatientSensitiveInfo,
@@ -31,11 +31,11 @@ import {
   PatientClinic,
   SearchPatientsParams,
   RequesterInfo,
-} from '../../types/patient';
-import { Auth } from 'firebase/auth';
-import { Firestore } from 'firebase/firestore';
-import { FirebaseApp } from 'firebase/app';
-import { Timestamp } from 'firebase/firestore';
+} from "../../types/patient";
+import { Auth } from "firebase/auth";
+import { Firestore } from "firebase/firestore";
+import { FirebaseApp } from "firebase/app";
+import { Timestamp } from "firebase/firestore";
 
 // Importujemo utility funkcije
 import {
@@ -52,20 +52,20 @@ import {
   updatePatientProfileByUserRefUtil,
   searchPatientsUtil,
   getAllPatientsUtil,
-} from './utils/profile.utils';
+} from "./utils/profile.utils";
 
 import {
   updatePatientLocationUtil,
   createLocationInfoUtil,
   getLocationInfoUtil,
   updateLocationInfoUtil,
-} from './utils/location.utils';
+} from "./utils/location.utils";
 
 import {
   createSensitiveInfoUtil,
   getSensitiveInfoUtil,
   updateSensitiveInfoUtil,
-} from './utils/sensitive.utils';
+} from "./utils/sensitive.utils";
 
 import {
   createMedicalInfoUtil,
@@ -83,21 +83,24 @@ import {
   addMedicationUtil,
   updateMedicationUtil,
   removeMedicationUtil,
-} from './utils/medical.utils';
+} from "./utils/medical.utils";
 
 import {
   getPatientDocRef,
   getSensitiveInfoDocRef,
   getLocationInfoDocRef,
   getMedicalInfoDocRef,
-} from './utils/docs.utils';
+} from "./utils/docs.utils";
 
 import {
   addDoctorUtil,
   removeDoctorUtil,
   addClinicUtil,
   removeClinicUtil,
-} from './utils/medical-stuff.utils';
+} from "./utils/medical-stuff.utils";
+
+import { getPatientsByPractitionerUtil } from "./utils/practitioner.utils";
+import { getPatientsByClinicUtil } from "./utils/clinic.utils";
 
 export class PatientService extends BaseService {
   constructor(db: Firestore, auth: Auth, app: FirebaseApp) {
@@ -105,7 +108,9 @@ export class PatientService extends BaseService {
   }
 
   // Metode za rad sa profilom pacijenta
-  async createPatientProfile(data: CreatePatientProfileData): Promise<PatientProfile> {
+  async createPatientProfile(
+    data: CreatePatientProfileData
+  ): Promise<PatientProfile> {
     return createPatientProfileUtil(this.db, data, () => this.generateId());
   }
 
@@ -113,7 +118,9 @@ export class PatientService extends BaseService {
     return getPatientProfileUtil(this.db, patientId);
   }
 
-  async getPatientProfileByUserRef(userRef: string): Promise<PatientProfile | null> {
+  async getPatientProfileByUserRef(
+    userRef: string
+  ): Promise<PatientProfile | null> {
     return getPatientProfileByUserRefUtil(this.db, userRef);
   }
 
@@ -121,7 +128,7 @@ export class PatientService extends BaseService {
   async updatePatientLocation(
     patientId: string,
     latitude: number,
-    longitude: number,
+    longitude: number
   ): Promise<void> {
     await updatePatientLocationUtil(this.db, patientId, latitude, longitude);
   }
@@ -129,30 +136,30 @@ export class PatientService extends BaseService {
   async updatePatientLocationByUserRef(
     userRef: string,
     latitude: number,
-    longitude: number,
+    longitude: number
   ): Promise<void> {
     const profile = await this.getPatientProfileByUserRef(userRef);
-    if (!profile) throw new Error('Patient profile not found');
+    if (!profile) throw new Error("Patient profile not found");
     await this.updatePatientLocation(profile.id, latitude, longitude);
   }
 
   async createLocationInfo(
     data: CreatePatientLocationInfoData,
-    requesterId: string,
+    requesterId: string
   ): Promise<PatientLocationInfo> {
     return createLocationInfoUtil(this.db, data, requesterId);
   }
 
   async getLocationInfo(
     patientId: string,
-    requesterId: string,
+    requesterId: string
   ): Promise<PatientLocationInfo | null> {
     return getLocationInfoUtil(this.db, patientId, requesterId);
   }
 
   async getLocationInfoByUserRef(
     userRef: string,
-    requesterId: string,
+    requesterId: string
   ): Promise<PatientLocationInfo | null> {
     const profile = await this.getPatientProfileByUserRef(userRef);
     if (!profile) return null;
@@ -162,7 +169,7 @@ export class PatientService extends BaseService {
   async updateLocationInfo(
     patientId: string,
     data: UpdatePatientLocationInfoData,
-    requesterId: string,
+    requesterId: string
   ): Promise<PatientLocationInfo> {
     return updateLocationInfoUtil(this.db, patientId, data, requesterId);
   }
@@ -170,21 +177,21 @@ export class PatientService extends BaseService {
   // Metode za rad sa osetljivim informacijama
   async createSensitiveInfo(
     data: CreatePatientSensitiveInfoData,
-    requesterUserId: string,
+    requesterUserId: string
   ): Promise<PatientSensitiveInfo> {
     return createSensitiveInfoUtil(this.db, data, requesterUserId);
   }
 
   async getSensitiveInfo(
     patientId: string,
-    requesterUserId: string,
+    requesterUserId: string
   ): Promise<PatientSensitiveInfo | null> {
     return getSensitiveInfoUtil(this.db, patientId, requesterUserId);
   }
 
   async getSensitiveInfoByUserRef(
     userRef: string,
-    requesterUserId: string,
+    requesterUserId: string
   ): Promise<PatientSensitiveInfo | null> {
     const profile = await this.getPatientProfileByUserRef(userRef);
     if (!profile) return null;
@@ -194,30 +201,47 @@ export class PatientService extends BaseService {
   async updateSensitiveInfo(
     patientId: string,
     data: UpdatePatientSensitiveInfoData,
-    requesterUserId: string,
+    requesterUserId: string
   ): Promise<PatientSensitiveInfo> {
     return updateSensitiveInfoUtil(this.db, patientId, data, requesterUserId);
   }
 
   // Metode za rad sa medicinskim informacijama
-  async createMedicalInfo(patientId: string, data: CreatePatientMedicalInfoData): Promise<void> {
+  async createMedicalInfo(
+    patientId: string,
+    data: CreatePatientMedicalInfoData
+  ): Promise<void> {
     const currentUser = await this.getCurrentUser();
-    await createMedicalInfoUtil(this.db, patientId, data, currentUser.uid, currentUser.roles);
+    await createMedicalInfoUtil(
+      this.db,
+      patientId,
+      data,
+      currentUser.uid,
+      currentUser.roles
+    );
   }
 
   async getMedicalInfo(patientId: string): Promise<PatientMedicalInfo> {
     const currentUser = await this.getCurrentUser();
-    return getMedicalInfoUtil(this.db, patientId, currentUser.uid, currentUser.roles);
+    return getMedicalInfoUtil(
+      this.db,
+      patientId,
+      currentUser.uid,
+      currentUser.roles
+    );
   }
 
   async getMedicalInfoByUserRef(userRef: string): Promise<PatientMedicalInfo> {
     const profile = await this.getPatientProfileByUserRef(userRef);
-    if (!profile) throw new Error('Patient profile not found');
+    if (!profile) throw new Error("Patient profile not found");
     return this.getMedicalInfo(profile.id);
   }
 
   // Metode za rad sa vitalnim statistikama
-  async updateVitalStats(patientId: string, data: UpdateVitalStatsData): Promise<void> {
+  async updateVitalStats(
+    patientId: string,
+    data: UpdateVitalStatsData
+  ): Promise<void> {
     const currentUser = await this.getCurrentUser();
     await updateVitalStatsUtil(this.db, patientId, data, currentUser.uid);
   }
@@ -228,7 +252,10 @@ export class PatientService extends BaseService {
     await addAllergyUtil(this.db, patientId, data, currentUser.uid);
   }
 
-  async updateAllergy(patientId: string, data: UpdateAllergyData): Promise<void> {
+  async updateAllergy(
+    patientId: string,
+    data: UpdateAllergyData
+  ): Promise<void> {
     const currentUser = await this.getCurrentUser();
     await updateAllergyUtil(this.db, patientId, data, currentUser.uid);
   }
@@ -239,54 +266,98 @@ export class PatientService extends BaseService {
   }
 
   // Metode za rad sa blocking conditions
-  async addBlockingCondition(patientId: string, data: AddBlockingConditionData): Promise<void> {
+  async addBlockingCondition(
+    patientId: string,
+    data: AddBlockingConditionData
+  ): Promise<void> {
     const currentUser = await this.getCurrentUser();
     await addBlockingConditionUtil(this.db, patientId, data, currentUser.uid);
   }
 
   async updateBlockingCondition(
     patientId: string,
-    data: UpdateBlockingConditionData,
+    data: UpdateBlockingConditionData
   ): Promise<void> {
     const currentUser = await this.getCurrentUser();
-    await updateBlockingConditionUtil(this.db, patientId, data, currentUser.uid);
+    await updateBlockingConditionUtil(
+      this.db,
+      patientId,
+      data,
+      currentUser.uid
+    );
   }
 
-  async removeBlockingCondition(patientId: string, conditionIndex: number): Promise<void> {
+  async removeBlockingCondition(
+    patientId: string,
+    conditionIndex: number
+  ): Promise<void> {
     const currentUser = await this.getCurrentUser();
-    await removeBlockingConditionUtil(this.db, patientId, conditionIndex, currentUser.uid);
+    await removeBlockingConditionUtil(
+      this.db,
+      patientId,
+      conditionIndex,
+      currentUser.uid
+    );
   }
 
   // Metode za rad sa kontraindikacijama
-  async addContraindication(patientId: string, data: AddContraindicationData): Promise<void> {
+  async addContraindication(
+    patientId: string,
+    data: AddContraindicationData
+  ): Promise<void> {
     const currentUser = await this.getCurrentUser();
     await addContraindicationUtil(this.db, patientId, data, currentUser.uid);
   }
 
-  async updateContraindication(patientId: string, data: UpdateContraindicationData): Promise<void> {
+  async updateContraindication(
+    patientId: string,
+    data: UpdateContraindicationData
+  ): Promise<void> {
     const currentUser = await this.getCurrentUser();
     await updateContraindicationUtil(this.db, patientId, data, currentUser.uid);
   }
 
-  async removeContraindication(patientId: string, contraindicationIndex: number): Promise<void> {
+  async removeContraindication(
+    patientId: string,
+    contraindicationIndex: number
+  ): Promise<void> {
     const currentUser = await this.getCurrentUser();
-    await removeContraindicationUtil(this.db, patientId, contraindicationIndex, currentUser.uid);
+    await removeContraindicationUtil(
+      this.db,
+      patientId,
+      contraindicationIndex,
+      currentUser.uid
+    );
   }
 
   // Metode za rad sa medikacijama
-  async addMedication(patientId: string, data: AddMedicationData): Promise<void> {
+  async addMedication(
+    patientId: string,
+    data: AddMedicationData
+  ): Promise<void> {
     const currentUser = await this.getCurrentUser();
     await addMedicationUtil(this.db, patientId, data, currentUser.uid);
   }
 
-  async updateMedication(patientId: string, data: UpdateMedicationData): Promise<void> {
+  async updateMedication(
+    patientId: string,
+    data: UpdateMedicationData
+  ): Promise<void> {
     const currentUser = await this.getCurrentUser();
     await updateMedicationUtil(this.db, patientId, data, currentUser.uid);
   }
 
-  async removeMedication(patientId: string, medicationIndex: number): Promise<void> {
+  async removeMedication(
+    patientId: string,
+    medicationIndex: number
+  ): Promise<void> {
     const currentUser = await this.getCurrentUser();
-    await removeMedicationUtil(this.db, patientId, medicationIndex, currentUser.uid);
+    await removeMedicationUtil(
+      this.db,
+      patientId,
+      medicationIndex,
+      currentUser.uid
+    );
   }
 
   // Pomoćne metode
@@ -296,7 +367,7 @@ export class PatientService extends BaseService {
 
   async addExpoTokenByUserRef(userRef: string, token: string): Promise<void> {
     const profile = await this.getPatientProfileByUserRef(userRef);
-    if (!profile) throw new Error('Patient profile not found');
+    if (!profile) throw new Error("Patient profile not found");
     await this.addExpoToken(profile.id, token);
   }
 
@@ -304,9 +375,12 @@ export class PatientService extends BaseService {
     await removeExpoTokenUtil(this.db, patientId, token);
   }
 
-  async removeExpoTokenByUserRef(userRef: string, token: string): Promise<void> {
+  async removeExpoTokenByUserRef(
+    userRef: string,
+    token: string
+  ): Promise<void> {
     const profile = await this.getPatientProfileByUserRef(userRef);
-    if (!profile) throw new Error('Patient profile not found');
+    if (!profile) throw new Error("Patient profile not found");
     await this.removeExpoToken(profile.id, token);
   }
 
@@ -316,17 +390,19 @@ export class PatientService extends BaseService {
 
   async addPointsByUserRef(userRef: string, points: number): Promise<void> {
     const profile = await this.getPatientProfileByUserRef(userRef);
-    if (!profile) throw new Error('Patient profile not found');
+    if (!profile) throw new Error("Patient profile not found");
     await this.addPoints(profile.id, points);
   }
 
   private async getCurrentUser(): Promise<any> {
     if (!this.auth.currentUser) {
-      throw new Error('No authenticated user');
+      throw new Error("No authenticated user");
     }
-    const userDoc = await getDoc(doc(this.db, 'users', this.auth.currentUser.uid));
+    const userDoc = await getDoc(
+      doc(this.db, "users", this.auth.currentUser.uid)
+    );
     if (!userDoc.exists()) {
-      throw new Error('User not found');
+      throw new Error("User not found");
     }
     return userDoc.data();
   }
@@ -388,14 +464,14 @@ export class PatientService extends BaseService {
   // Metode za ažuriranje profila
   async updatePatientProfile(
     patientId: string,
-    data: Partial<Omit<PatientProfile, 'id' | 'createdAt' | 'updatedAt'>>,
+    data: Partial<Omit<PatientProfile, "id" | "createdAt" | "updatedAt">>
   ): Promise<PatientProfile> {
     return updatePatientProfileUtil(this.db, patientId, data);
   }
 
   async updatePatientProfileByUserRef(
     userRef: string,
-    data: Partial<Omit<PatientProfile, 'id' | 'createdAt' | 'updatedAt'>>,
+    data: Partial<Omit<PatientProfile, "id" | "createdAt" | "updatedAt">>
   ): Promise<PatientProfile> {
     return updatePatientProfileByUserRefUtil(this.db, userRef, data);
   }
@@ -410,7 +486,7 @@ export class PatientService extends BaseService {
    */
   async searchPatients(
     params: SearchPatientsParams,
-    requester: RequesterInfo,
+    requester: RequesterInfo
   ): Promise<PatientProfile[]> {
     // We can potentially add more service-level logic here in the future,
     // like fetching additional data or enriching the results.
@@ -419,7 +495,7 @@ export class PatientService extends BaseService {
       `[PatientService.searchPatients] Initiating search with params:`,
       params,
       `by requester:`,
-      requester,
+      requester
     );
 
     // The utility function already handles validation and security checks.
@@ -438,7 +514,54 @@ export class PatientService extends BaseService {
     limit?: number;
     startAfter?: string;
   }): Promise<PatientProfile[]> {
-    console.log(`[PatientService.getAllPatients] Fetching patients with options:`, options);
+    console.log(
+      `[PatientService.getAllPatients] Fetching patients with options:`,
+      options
+    );
     return getAllPatientsUtil(this.db, options);
   }
+
+  /**
+   * Gets all patients associated with a specific practitioner.
+   *
+   * @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
+   */
+  async getPatientsByPractitioner(
+    practitionerId: string,
+    options?: {
+      limit?: number;
+      startAfter?: string;
+    }
+  ): Promise<PatientProfile[]> {
+    console.log(
+      `[PatientService.getPatientsByPractitioner] Fetching patients for practitioner: ${practitionerId}`
+    );
+    return getPatientsByPractitionerUtil(this.db, practitionerId, options);
+  }
+
+  /**
+   * Gets all patients associated with a specific clinic.
+   *
+   * @param {string} clinicId - ID of the clinic 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
+   */
+  async getPatientsByClinic(
+    clinicId: string,
+    options?: {
+      limit?: number;
+      startAfter?: string;
+    }
+  ): Promise<PatientProfile[]> {
+    console.log(
+      `[PatientService.getPatientsByClinic] Fetching patients for clinic: ${clinicId}`
+    );
+    return getPatientsByClinicUtil(this.db, clinicId, options);
+  }
 }

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

@@ -0,0 +1,80 @@
+import {
+  collection,
+  query,
+  where,
+  getDocs,
+  Firestore,
+  limit,
+  startAfter,
+  doc,
+  getDoc,
+  QueryConstraint,
+} from "firebase/firestore";
+import { PatientProfile, PATIENTS_COLLECTION } from "../../../types/patient";
+
+/**
+ * Retrieves all patients associated with a specific clinic with pagination support.
+ *
+ * @param {Firestore} db - Firestore instance
+ * @param {string} clinicId - ID of the clinic 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 getPatientsByClinicUtil = async (
+  db: Firestore,
+  clinicId: string,
+  options?: { limit?: number; startAfter?: string }
+): Promise<PatientProfile[]> => {
+  try {
+    console.log(
+      `[getPatientsByClinicUtil] Fetching patients for clinic ID: ${clinicId} with options:`,
+      options
+    );
+
+    const patientsCollection = collection(db, PATIENTS_COLLECTION);
+    const constraints: QueryConstraint[] = [
+      where("clinicIds", "array-contains", clinicId),
+    ];
+
+    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(
+      `[getPatientsByClinicUtil] Found ${patients.length} patients for clinic ID: ${clinicId}`
+    );
+    return patients;
+  } catch (error) {
+    console.error(
+      `[getPatientsByClinicUtil] Error fetching patients for clinic:`,
+      error
+    );
+    throw new Error(
+      `Failed to retrieve patients for clinic: ${
+        error instanceof Error ? error.message : String(error)
+      }`
+    );
+  }
+};

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

@@ -0,0 +1,80 @@
+import {
+  collection,
+  query,
+  where,
+  getDocs,
+  Firestore,
+  limit,
+  startAfter,
+  doc,
+  getDoc,
+  QueryConstraint,
+} from "firebase/firestore";
+import { PatientProfile, PATIENTS_COLLECTION } from "../../../types/patient";
+
+/**
+ * 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)
+      }`
+    );
+  }
+};