@blackcode_sa/metaestetics-api 1.5.16 → 1.5.18

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

@@ -8,47 +8,54 @@ import {
   increment,
   Firestore,
   Timestamp,
-} from "firebase/firestore";
-import {
-  ref,
-  uploadBytes,
-  getDownloadURL,
-  deleteObject,
-  FirebaseStorage,
-} from "firebase/storage";
-import { z } from "zod";
+  collection,
+  query,
+  where,
+  getDocs,
+  QueryConstraint,
+  limit,
+  startAfter,
+  doc,
+} from 'firebase/firestore';
+import { ref, uploadBytes, getDownloadURL, deleteObject, FirebaseStorage } from 'firebase/storage';
+import { z } from 'zod';
 import {
   PatientProfile,
   CreatePatientProfileData,
   Gender,
-} from "../../../types/patient";
+  SearchPatientsParams,
+  RequesterInfo,
+  PATIENTS_COLLECTION,
+} from '../../../types/patient';
 import {
   patientProfileSchema,
   createPatientProfileSchema,
-} from "../../../validations/patient.schema";
+  searchPatientsSchema,
+  requesterInfoSchema,
+} from '../../../validations/patient.schema';
 import {
   getPatientDocRef,
   getPatientDocRefByUserRef,
   initSensitiveInfoDocIfNotExists,
   getSensitiveInfoDocRef,
   getMedicalInfoDocRef,
-} from "./docs.utils";
-import { ensureMedicalInfoExists } from "./medical.utils";
-import { DEFAULT_MEDICAL_INFO } from "../../../types/patient/medical-info.types";
+} from './docs.utils';
+import { ensureMedicalInfoExists } from './medical.utils';
+import { DEFAULT_MEDICAL_INFO } from '../../../types/patient/medical-info.types';
 
 // Funkcije za rad sa profilom
 export const createPatientProfileUtil = async (
   db: Firestore,
   data: CreatePatientProfileData,
-  generateId: () => string
+  generateId: () => string,
 ): Promise<PatientProfile> => {
   try {
-    console.log("[createPatientProfileUtil] Starting patient profile creation");
+    console.log('[createPatientProfileUtil] Starting patient profile creation');
     const validatedData = createPatientProfileSchema.parse(data);
     const patientId = generateId();
     console.log(`[createPatientProfileUtil] Generated patientId: ${patientId}`);
 
-    const patientData: Omit<PatientProfile, "createdAt" | "updatedAt"> & {
+    const patientData: Omit<PatientProfile, 'createdAt' | 'updatedAt'> & {
       createdAt: ReturnType<typeof serverTimestamp>;
       updatedAt: ReturnType<typeof serverTimestamp>;
     } = {
@@ -65,6 +72,8 @@ export const createPatientProfileUtil = async (
       isVerified: validatedData.isVerified,
       doctors: validatedData.doctors || [],
       clinics: validatedData.clinics || [],
+      doctorIds: validatedData.doctors?.map((d) => d.userRef) || [],
+      clinicIds: validatedData.clinics?.map((c) => c.clinicId) || [],
       createdAt: serverTimestamp(),
       updatedAt: serverTimestamp(),
     };
@@ -84,21 +93,16 @@ export const createPatientProfileUtil = async (
       const sensitiveInfoCreated = await initSensitiveInfoDocIfNotExists(
         db,
         patientId,
-        validatedData.userRef
+        validatedData.userRef,
       );
       console.log(
         `[createPatientProfileUtil] Sensitive info document creation result: ${
-          sensitiveInfoCreated
-            ? "Document already existed"
-            : "New document created"
-        }`
+          sensitiveInfoCreated ? 'Document already existed' : 'New document created'
+        }`,
       );
       sensitiveInfoSuccess = true;
     } catch (sensitiveError) {
-      console.error(
-        `[createPatientProfileUtil] Error creating sensitive info:`,
-        sensitiveError
-      );
+      console.error(`[createPatientProfileUtil] Error creating sensitive info:`, sensitiveError);
       // Don't throw the error, we'll try the direct method
     }
 
@@ -107,33 +111,21 @@ export const createPatientProfileUtil = async (
     let medicalInfoSuccess = false;
     try {
       await ensureMedicalInfoExists(db, patientId, validatedData.userRef);
-      console.log(
-        `[createPatientProfileUtil] Medical info document created successfully`
-      );
+      console.log(`[createPatientProfileUtil] Medical info document created successfully`);
       medicalInfoSuccess = true;
     } catch (medicalError) {
-      console.error(
-        `[createPatientProfileUtil] Error creating medical info:`,
-        medicalError
-      );
+      console.error(`[createPatientProfileUtil] Error creating medical info:`, medicalError);
       // Don't throw the error, we'll try the direct method
     }
 
     // If either utility function failed, try the direct method
     if (!sensitiveInfoSuccess || !medicalInfoSuccess) {
-      console.log(
-        `[createPatientProfileUtil] Using fallback method to create documents`
-      );
+      console.log(`[createPatientProfileUtil] Using fallback method to create documents`);
       try {
         await testCreateSubDocuments(db, patientId, validatedData.userRef);
-        console.log(
-          `[createPatientProfileUtil] Fallback method completed successfully`
-        );
+        console.log(`[createPatientProfileUtil] Fallback method completed successfully`);
       } catch (fallbackError) {
-        console.error(
-          `[createPatientProfileUtil] Fallback method failed:`,
-          fallbackError
-        );
+        console.error(`[createPatientProfileUtil] Fallback method failed:`, fallbackError);
         // Still continue to return the patient profile
       }
     }
@@ -141,23 +133,16 @@ export const createPatientProfileUtil = async (
     console.log(`[createPatientProfileUtil] Verifying patient document exists`);
     const patientDoc = await getDoc(getPatientDocRef(db, patientId));
     if (!patientDoc.exists()) {
-      console.error(
-        `[createPatientProfileUtil] Patient document not found after creation`
-      );
-      throw new Error("Failed to create patient profile");
+      console.error(`[createPatientProfileUtil] Patient document not found after creation`);
+      throw new Error('Failed to create patient profile');
     }
 
-    console.log(
-      `[createPatientProfileUtil] Patient profile creation completed successfully`
-    );
+    console.log(`[createPatientProfileUtil] Patient profile creation completed successfully`);
     return patientDoc.data() as PatientProfile;
   } catch (error) {
-    console.error(
-      `[createPatientProfileUtil] Error in patient profile creation:`,
-      error
-    );
+    console.error(`[createPatientProfileUtil] Error in patient profile creation:`, error);
     if (error instanceof z.ZodError) {
-      throw new Error("Invalid patient data: " + error.message);
+      throw new Error('Invalid patient data: ' + error.message);
     }
     throw error;
   }
@@ -165,7 +150,7 @@ export const createPatientProfileUtil = async (
 
 export const getPatientProfileUtil = async (
   db: Firestore,
-  patientId: string
+  patientId: string,
 ): Promise<PatientProfile | null> => {
   const patientDoc = await getDoc(getPatientDocRef(db, patientId));
   return patientDoc.exists() ? (patientDoc.data() as PatientProfile) : null;
@@ -173,7 +158,7 @@ export const getPatientProfileUtil = async (
 
 export const getPatientProfileByUserRefUtil = async (
   db: Firestore,
-  userRef: string
+  userRef: string,
 ): Promise<PatientProfile | null> => {
   try {
     const docRef = await getPatientDocRefByUserRef(db, userRef);
@@ -188,7 +173,7 @@ export const getPatientProfileByUserRefUtil = async (
 export const addExpoTokenUtil = async (
   db: Firestore,
   patientId: string,
-  token: string
+  token: string,
 ): Promise<void> => {
   await updateDoc(getPatientDocRef(db, patientId), {
     expoTokens: arrayUnion(token),
@@ -199,7 +184,7 @@ export const addExpoTokenUtil = async (
 export const removeExpoTokenUtil = async (
   db: Firestore,
   patientId: string,
-  token: string
+  token: string,
 ): Promise<void> => {
   await updateDoc(getPatientDocRef(db, patientId), {
     expoTokens: arrayRemove(token),
@@ -210,10 +195,10 @@ export const removeExpoTokenUtil = async (
 export const addPointsUtil = async (
   db: Firestore,
   patientId: string,
-  points: number
+  points: number,
 ): Promise<void> => {
   await updateDoc(getPatientDocRef(db, patientId), {
-    "gamification.points": increment(points),
+    'gamification.points': increment(points),
     updatedAt: serverTimestamp(),
   });
 };
@@ -221,7 +206,7 @@ export const addPointsUtil = async (
 export const updatePatientProfileUtil = async (
   db: Firestore,
   patientId: string,
-  data: Partial<Omit<PatientProfile, "id" | "createdAt" | "updatedAt">>
+  data: Partial<Omit<PatientProfile, 'id' | 'createdAt' | 'updatedAt'>>,
 ): Promise<PatientProfile> => {
   try {
     const updateData = {
@@ -233,7 +218,7 @@ export const updatePatientProfileUtil = async (
 
     const updatedDoc = await getDoc(getPatientDocRef(db, patientId));
     if (!updatedDoc.exists()) {
-      throw new Error("Patient profile not found after update");
+      throw new Error('Patient profile not found after update');
     }
 
     return updatedDoc.data() as PatientProfile;
@@ -246,23 +231,21 @@ export const updatePatientProfileUtil = async (
 export const updatePatientProfileByUserRefUtil = async (
   db: Firestore,
   userRef: string,
-  data: Partial<Omit<PatientProfile, "id" | "createdAt" | "updatedAt">>
+  data: Partial<Omit<PatientProfile, 'id' | 'createdAt' | 'updatedAt'>>,
 ): Promise<PatientProfile> => {
   try {
     const docRef = await getPatientDocRefByUserRef(db, userRef);
     const patientDoc = await getDoc(docRef);
 
     if (!patientDoc.exists()) {
-      throw new Error("Patient profile not found");
+      throw new Error('Patient profile not found');
     }
 
     const patientData = patientDoc.data() as PatientProfile;
     return updatePatientProfileUtil(db, patientData.id, data);
   } catch (error: unknown) {
     const errorMessage = error instanceof Error ? error.message : String(error);
-    throw new Error(
-      `Failed to update patient profile by user ref: ${errorMessage}`
-    );
+    throw new Error(`Failed to update patient profile by user ref: ${errorMessage}`);
   }
 };
 
@@ -270,7 +253,7 @@ export const updatePatientProfileByUserRefUtil = async (
 export const uploadProfilePhotoUtil = async (
   storage: FirebaseStorage,
   patientId: string,
-  file: File
+  file: File,
 ): Promise<string> => {
   const photoRef = ref(storage, `patient-photos/${patientId}/profile-photo`);
   await uploadBytes(photoRef, file);
@@ -281,11 +264,11 @@ export const updateProfilePhotoUtil = async (
   storage: FirebaseStorage,
   db: Firestore,
   patientId: string,
-  file: File
+  file: File,
 ): Promise<string> => {
   // Prvo obrišemo staru sliku ako postoji
   const patientDoc = await getDoc(getPatientDocRef(db, patientId));
-  if (!patientDoc.exists()) throw new Error("Patient profile not found");
+  if (!patientDoc.exists()) throw new Error('Patient profile not found');
 
   const patientData = patientDoc.data() as PatientProfile;
   if (patientData.profilePhoto) {
@@ -293,7 +276,7 @@ export const updateProfilePhotoUtil = async (
       const oldPhotoRef = ref(storage, patientData.profilePhoto);
       await deleteObject(oldPhotoRef);
     } catch (error) {
-      console.warn("Failed to delete old profile photo:", error);
+      console.warn('Failed to delete old profile photo:', error);
     }
   }
 
@@ -312,10 +295,10 @@ export const updateProfilePhotoUtil = async (
 export const deleteProfilePhotoUtil = async (
   storage: FirebaseStorage,
   db: Firestore,
-  patientId: string
+  patientId: string,
 ): Promise<void> => {
   const patientDoc = await getDoc(getPatientDocRef(db, patientId));
-  if (!patientDoc.exists()) throw new Error("Patient profile not found");
+  if (!patientDoc.exists()) throw new Error('Patient profile not found');
 
   const patientData = patientDoc.data() as PatientProfile;
   if (patientData.profilePhoto) {
@@ -323,7 +306,7 @@ export const deleteProfilePhotoUtil = async (
       const photoRef = ref(storage, patientData.profilePhoto);
       await deleteObject(photoRef);
     } catch (error) {
-      console.warn("Failed to delete profile photo:", error);
+      console.warn('Failed to delete profile photo:', error);
     }
   }
 
@@ -340,45 +323,39 @@ export const deleteProfilePhotoUtil = async (
 export const testCreateSubDocuments = async (
   db: Firestore,
   patientId: string,
-  userRef: string
+  userRef: string,
 ): Promise<void> => {
   console.log(
-    `[testCreateSubDocuments] Starting test for patientId: ${patientId}, userRef: ${userRef}`
+    `[testCreateSubDocuments] Starting test for patientId: ${patientId}, userRef: ${userRef}`,
   );
 
   try {
     // Test sensitive info creation
     console.log(`[testCreateSubDocuments] Testing sensitive info creation`);
     const sensitiveInfoRef = getSensitiveInfoDocRef(db, patientId);
-    console.log(
-      `[testCreateSubDocuments] Sensitive info path: ${sensitiveInfoRef.path}`
-    );
+    console.log(`[testCreateSubDocuments] Sensitive info path: ${sensitiveInfoRef.path}`);
 
     const defaultSensitiveInfo = {
       patientId,
       userRef,
-      photoUrl: "",
-      firstName: "Name",
-      lastName: "Surname",
+      photoUrl: '',
+      firstName: 'Name',
+      lastName: 'Surname',
       dateOfBirth: Timestamp.now(),
       gender: Gender.PREFER_NOT_TO_SAY,
-      email: "test@example.com",
-      phoneNumber: "",
+      email: 'test@example.com',
+      phoneNumber: '',
       createdAt: Timestamp.now(),
       updatedAt: Timestamp.now(),
     };
 
     await setDoc(sensitiveInfoRef, defaultSensitiveInfo);
-    console.log(
-      `[testCreateSubDocuments] Sensitive info document created directly`
-    );
+    console.log(`[testCreateSubDocuments] Sensitive info document created directly`);
 
     // Test medical info creation
     console.log(`[testCreateSubDocuments] Testing medical info creation`);
     const medicalInfoRef = getMedicalInfoDocRef(db, patientId);
-    console.log(
-      `[testCreateSubDocuments] Medical info path: ${medicalInfoRef.path}`
-    );
+    console.log(`[testCreateSubDocuments] Medical info path: ${medicalInfoRef.path}`);
 
     const defaultMedicalInfo = {
       ...DEFAULT_MEDICAL_INFO,
@@ -388,9 +365,7 @@ export const testCreateSubDocuments = async (
     };
 
     await setDoc(medicalInfoRef, defaultMedicalInfo);
-    console.log(
-      `[testCreateSubDocuments] Medical info document created directly`
-    );
+    console.log(`[testCreateSubDocuments] Medical info document created directly`);
 
     console.log(`[testCreateSubDocuments] Test completed successfully`);
   } catch (error) {
@@ -398,3 +373,140 @@ export const testCreateSubDocuments = async (
     throw error;
   }
 };
+
+/**
+ * Searches for patient profiles based on clinic and/or practitioner association.
+ * Applies security checks based on the requester's role and associations.
+ *
+ * @param {Firestore} db - Firestore instance.
+ * @param {SearchPatientsParams} params - Search criteria (clinicId, practitionerId).
+ * @param {RequesterInfo} requester - Information about the user performing the search.
+ * @returns {Promise<PatientProfile[]>} A promise resolving to an array of matching patient profiles.
+ */
+export const searchPatientsUtil = async (
+  db: Firestore,
+  params: SearchPatientsParams,
+  requester: RequesterInfo,
+): Promise<PatientProfile[]> => {
+  // Validate input
+  searchPatientsSchema.parse(params);
+  requesterInfoSchema.parse(requester);
+
+  const constraints: QueryConstraint[] = [];
+  const patientsCollectionRef = collection(db, PATIENTS_COLLECTION);
+
+  // --- Security Checks & Initial Filtering ---
+
+  if (requester.role === 'clinic_admin') {
+    // Clinic admin can only search within their own clinic
+    if (!requester.associatedClinicId) {
+      throw new Error('Associated clinic ID is required for clinic admin search.');
+    }
+    // If the search params specify a different clinic, it's an invalid request for this admin.
+    if (params.clinicId && params.clinicId !== requester.associatedClinicId) {
+      console.warn(
+        `Clinic admin (${requester.id}) attempted to search outside their associated clinic (${requester.associatedClinicId})`,
+      );
+      return []; // Or throw an error
+    }
+
+    // **Mandatory filter**: Ensure patients belong to the admin's clinic.
+    constraints.push(where('clinicIds', 'array-contains', requester.associatedClinicId));
+
+    // Optional filter: If practitionerId is also provided, filter by that practitioner *within the admin's clinic*.
+    if (params.practitionerId) {
+      constraints.push(where('doctorIds', 'array-contains', params.practitionerId));
+      // We might need an additional check here if the practitioner MUST work at the admin's clinic.
+      // This would require fetching practitioner data or having denormalized clinic IDs on the practitioner.
+    }
+  } else if (requester.role === 'practitioner') {
+    // Practitioner can only search for their own patients.
+    if (!requester.associatedPractitionerId) {
+      throw new Error('Associated practitioner ID is required for practitioner search.');
+    }
+    // If the search params specify a different practitioner, it's invalid.
+    if (params.practitionerId && params.practitionerId !== requester.associatedPractitionerId) {
+      console.warn(
+        `Practitioner (${requester.id}) attempted to search for patients of another practitioner (${params.practitionerId})`,
+      );
+      return []; // Or throw an error
+    }
+
+    // **Mandatory filter**: Ensure patients are associated with this practitioner.
+    constraints.push(where('doctorIds', 'array-contains', requester.associatedPractitionerId));
+
+    // Optional filter: If clinicId is provided, filter by patients of this practitioner *at that specific clinic*.
+    if (params.clinicId) {
+      constraints.push(where('clinicIds', 'array-contains', params.clinicId));
+      // Similar to above, we might need to check if the practitioner actually works at this clinic.
+    }
+  } else {
+    // Should not happen due to validation, but good practice to handle.
+    throw new Error('Invalid requester role.');
+  }
+
+  // --- Execute Query ---
+  try {
+    const finalQuery = query(patientsCollectionRef, ...constraints);
+    const querySnapshot = await getDocs(finalQuery);
+
+    const patients = querySnapshot.docs.map((doc) => doc.data() as PatientProfile);
+
+    console.log(`[searchPatientsUtil] Found ${patients.length} patients matching criteria.`);
+    return patients;
+  } catch (error) {
+    console.error('[searchPatientsUtil] Error searching patients:', error);
+    // Consider logging more details or re-throwing a specific error type
+    return []; // Return empty array on error
+  }
+};
+
+/**
+ * Retrieves all patient profiles from the database.
+ *
+ * @param {Firestore} db - Firestore instance
+ * @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
+ */
+export const getAllPatientsUtil = async (
+  db: Firestore,
+  options?: { limit?: number; startAfter?: string },
+): Promise<PatientProfile[]> => {
+  try {
+    console.log(`[getAllPatientsUtil] Fetching patients with options:`, options);
+
+    const patientsCollection = collection(db, PATIENTS_COLLECTION);
+
+    let q = query(patientsCollection);
+
+    // 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(`[getAllPatientsUtil] Found ${patients.length} patients`);
+    return patients;
+  } catch (error) {
+    console.error(`[getAllPatientsUtil] Error fetching patients:`, error);
+    throw new Error(
+      `Failed to retrieve patients: ${error instanceof Error ? error.message : String(error)}`,
+    );
+  }
+};

package/src/types/calendar/index.ts

@@ -185,3 +185,44 @@ export interface UpdateAppointmentParams {
  * Collection names for calendar
  */
 export const CALENDAR_COLLECTION = "calendar";
+
+/**
+ * Enum for specifying the primary search location for calendar events
+ */
+export enum SearchLocationEnum {
+  PRACTITIONER = "practitioner",
+  PATIENT = "patient",
+  CLINIC = "clinic", // Represents searching events associated with a clinic
+}
+
+/**
+ * Interface for defining a date range
+ */
+export interface DateRange {
+  start: Timestamp;
+  end: Timestamp;
+}
+
+/**
+ * Interface for general calendar event search parameters
+ */
+export interface SearchCalendarEventsParams {
+  /** The primary location to search within (practitioner, patient, or clinic calendar). */
+  searchLocation: SearchLocationEnum;
+  /** The ID of the entity (practitioner, patient, or clinic) whose calendar/events are being searched. */
+  entityId: string;
+  /** Optional filter for clinic ID. If searchLocation is CLINIC, this is implicitly applied using entityId. */
+  clinicId?: string;
+  /** Optional filter for practitioner ID. */
+  practitionerId?: string;
+  /** Optional filter for patient ID. */
+  patientId?: string;
+  /** Optional filter for procedure ID. */
+  procedureId?: string;
+  /** Optional filter for a specific date range (based on event start time). */
+  dateRange?: DateRange;
+  /** Optional filter for event status. */
+  eventStatus?: CalendarEventStatus;
+  /** Optional filter for event type. */
+  eventType?: CalendarEventType;
+}

package/src/types/patient/index.ts

@@ -172,6 +172,8 @@ export interface PatientProfile {
   dateOfBirth?: Timestamp | null;
   doctors: PatientDoctor[]; // Lista doktora pacijenta
   clinics: PatientClinic[]; // Lista klinika pacijenta
+  doctorIds: string[]; // Denormalized array for querying
+  clinicIds: string[]; // Denormalized array for querying
   createdAt: Timestamp;
   updatedAt: Timestamp;
 }
@@ -188,14 +190,42 @@ export interface CreatePatientProfileData {
   isVerified: boolean;
   doctors?: PatientDoctor[];
   clinics?: PatientClinic[];
+  doctorIds?: string[]; // Initialize as empty or with initial doctors
+  clinicIds?: string[]; // Initialize as empty or with initial clinics
 }
 
 /**
  * Tip za ažuriranje Patient profila
  */
 export interface UpdatePatientProfileData
-  extends Partial<CreatePatientProfileData> {
+  extends Partial<Omit<PatientProfile, "id" | "createdAt" | "updatedAt">> {
+  // Use Omit to exclude base fields
   updatedAt?: FieldValue;
+  // Note: doctors, clinics, doctorIds, clinicIds should ideally be updated via specific methods (add/removeDoctor/Clinic)
+}
+
+/**
+ * Parameters for searching patient profiles.
+ */
+export interface SearchPatientsParams {
+  /** Optional: Filter patients associated with this clinic ID. */
+  clinicId?: string;
+  /** Optional: Filter patients associated with this practitioner ID. */
+  practitionerId?: string;
+}
+
+/**
+ * Information about the entity requesting the patient search.
+ */
+export interface RequesterInfo {
+  /** ID of the clinic admin user or practitioner user making the request. */
+  id: string;
+  /** Role of the requester, determining the search context. */
+  role: "clinic_admin" | "practitioner";
+  /** If role is 'clinic_admin', this is the associated clinic ID. */
+  associatedClinicId?: string;
+  /** If role is 'practitioner', this is the associated practitioner profile ID. */
+  associatedPractitionerId?: string;
 }
 
 export * from "./medical-info.types";