@blackcode_sa/metaestetics-api 1.5.16 → 1.5.18

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,
@@ -29,11 +29,13 @@ import {
   UpdateMedicationData,
   PatientDoctor,
   PatientClinic,
-} from "../../types/patient";
-import { Auth } from "firebase/auth";
-import { Firestore } from "firebase/firestore";
-import { FirebaseApp } from "firebase/app";
-import { Timestamp } from "firebase/firestore";
+  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';
 
 // Importujemo utility funkcije
 import {
@@ -48,20 +50,22 @@ import {
   deleteProfilePhotoUtil,
   updatePatientProfileUtil,
   updatePatientProfileByUserRefUtil,
-} from "./utils/profile.utils";
+  searchPatientsUtil,
+  getAllPatientsUtil,
+} 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,
@@ -79,21 +83,21 @@ 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';
 
 export class PatientService extends BaseService {
   constructor(db: Firestore, auth: Auth, app: FirebaseApp) {
@@ -101,9 +105,7 @@ 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());
   }
 
@@ -111,9 +113,7 @@ 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 +121,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 +129,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 +162,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 +170,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,47 +194,30 @@ 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);
   }
@@ -245,10 +228,7 @@ 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);
   }
@@ -259,98 +239,54 @@ 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
@@ -360,7 +296,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);
   }
 
@@ -368,12 +304,9 @@ 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);
   }
 
@@ -383,19 +316,17 @@ 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();
   }
@@ -457,15 +388,57 @@ 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);
   }
+
+  /**
+   * Searches for patient profiles based on clinic/practitioner association.
+   * Requires information about the requester for security checks.
+   *
+   * @param {SearchPatientsParams} params - The search criteria (clinicId, practitionerId).
+   * @param {RequesterInfo} requester - Information about the user performing the search (ID, role, associated IDs).
+   * @returns {Promise<PatientProfile[]>} A promise resolving to an array of matching patient profiles.
+   */
+  async searchPatients(
+    params: SearchPatientsParams,
+    requester: RequesterInfo,
+  ): Promise<PatientProfile[]> {
+    // We can potentially add more service-level logic here in the future,
+    // like fetching additional data or enriching the results.
+    // For now, we delegate directly to the utility function.
+    console.log(
+      `[PatientService.searchPatients] Initiating search with params:`,
+      params,
+      `by requester:`,
+      requester,
+    );
+
+    // The utility function already handles validation and security checks.
+    return searchPatientsUtil(this.db, params, requester);
+  }
+
+  /**
+   * Gets all patient profiles.
+   *
+   * @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 all patient profiles.
+   */
+  async getAllPatients(options?: {
+    limit?: number;
+    startAfter?: string;
+  }): Promise<PatientProfile[]> {
+    console.log(`[PatientService.getAllPatients] Fetching patients with options:`, options);
+    return getAllPatientsUtil(this.db, options);
+  }
 }

package/src/services/patient/utils/medical-stuff.utils.ts

@@ -2,6 +2,7 @@ import {
   getDoc,
   updateDoc,
   arrayUnion,
+  arrayRemove,
   Firestore,
   serverTimestamp,
   Timestamp,
@@ -27,10 +28,32 @@ export const addDoctorUtil = async (
     isActive: true,
   };
 
-  await updateDoc(getPatientDocRef(db, patientId), {
-    doctors: arrayUnion(newDoctor),
+  const patientDoc = await getDoc(getPatientDocRef(db, patientId));
+  if (!patientDoc.exists()) throw new Error("Patient profile not found");
+  const patientData = patientDoc.data() as PatientProfile;
+  const existingDoctorIndex = patientData.doctors?.findIndex(
+    (d) => d.userRef === doctorRef
+  );
+
+  const updates: any = {
     updatedAt: serverTimestamp(),
-  });
+    doctorIds: arrayUnion(doctorRef),
+  };
+
+  if (existingDoctorIndex !== undefined && existingDoctorIndex > -1) {
+    const updatedDoctors = [...patientData.doctors];
+    updatedDoctors[existingDoctorIndex] = {
+      ...updatedDoctors[existingDoctorIndex],
+      isActive: true,
+      assignedAt: Timestamp.now(),
+      assignedBy,
+    };
+    updates.doctors = updatedDoctors;
+  } else {
+    updates.doctors = arrayUnion(newDoctor);
+  }
+
+  await updateDoc(getPatientDocRef(db, patientId), updates);
 };
 
 export const removeDoctorUtil = async (
@@ -38,16 +61,19 @@ export const removeDoctorUtil = async (
   patientId: string,
   doctorRef: string
 ): Promise<void> => {
-  const patientDoc = await getDoc(getPatientDocRef(db, patientId));
+  const patientDocRef = getPatientDocRef(db, patientId);
+  const patientDoc = await getDoc(patientDocRef);
   if (!patientDoc.exists()) throw new Error("Patient profile not found");
 
   const patientData = patientDoc.data() as PatientProfile;
-  const updatedDoctors = patientData.doctors.map((doctor) =>
-    doctor.userRef === doctorRef ? { ...doctor, isActive: false } : doctor
-  );
 
-  await updateDoc(getPatientDocRef(db, patientId), {
-    doctors: updatedDoctors,
+  // Filter out the doctor object by userRef
+  const updatedDoctors =
+    patientData.doctors?.filter((doctor) => doctor.userRef !== doctorRef) || []; // Ensure it's an array even if doctors field didn't exist or was empty
+
+  await updateDoc(patientDocRef, {
+    doctors: updatedDoctors, // Set the filtered array
+    doctorIds: arrayRemove(doctorRef), // Remove ID from the denormalized list
     updatedAt: serverTimestamp(),
   });
 };
@@ -66,10 +92,32 @@ export const addClinicUtil = async (
     isActive: true,
   };
 
-  await updateDoc(getPatientDocRef(db, patientId), {
-    clinics: arrayUnion(newClinic),
+  const patientDoc = await getDoc(getPatientDocRef(db, patientId));
+  if (!patientDoc.exists()) throw new Error("Patient profile not found");
+  const patientData = patientDoc.data() as PatientProfile;
+  const existingClinicIndex = patientData.clinics?.findIndex(
+    (c) => c.clinicId === clinicId
+  );
+
+  const updates: any = {
     updatedAt: serverTimestamp(),
-  });
+    clinicIds: arrayUnion(clinicId),
+  };
+
+  if (existingClinicIndex !== undefined && existingClinicIndex > -1) {
+    const updatedClinics = [...patientData.clinics];
+    updatedClinics[existingClinicIndex] = {
+      ...updatedClinics[existingClinicIndex],
+      isActive: true,
+      assignedAt: Timestamp.now(),
+      assignedBy,
+    };
+    updates.clinics = updatedClinics;
+  } else {
+    updates.clinics = arrayUnion(newClinic);
+  }
+
+  await updateDoc(getPatientDocRef(db, patientId), updates);
 };
 
 export const removeClinicUtil = async (
@@ -77,16 +125,19 @@ export const removeClinicUtil = async (
   patientId: string,
   clinicId: string
 ): Promise<void> => {
-  const patientDoc = await getDoc(getPatientDocRef(db, patientId));
+  const patientDocRef = getPatientDocRef(db, patientId);
+  const patientDoc = await getDoc(patientDocRef);
   if (!patientDoc.exists()) throw new Error("Patient profile not found");
 
   const patientData = patientDoc.data() as PatientProfile;
-  const updatedClinics = patientData.clinics.map((clinic) =>
-    clinic.clinicId === clinicId ? { ...clinic, isActive: false } : clinic
-  );
 
-  await updateDoc(getPatientDocRef(db, patientId), {
-    clinics: updatedClinics,
+  // Filter out the clinic object by clinicId
+  const updatedClinics =
+    patientData.clinics?.filter((clinic) => clinic.clinicId !== clinicId) || []; // Ensure it's an array
+
+  await updateDoc(patientDocRef, {
+    clinics: updatedClinics, // Set the filtered array
+    clinicIds: arrayRemove(clinicId), // Remove ID from the denormalized list
     updatedAt: serverTimestamp(),
   });
 };