@blackcode_sa/metaestetics-api 1.7.20 → 1.7.21

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

@@ -16,9 +16,8 @@ import {
   limit,
   startAfter,
   doc,
-} from 'firebase/firestore';
-import { ref, uploadBytes, getDownloadURL, deleteObject, FirebaseStorage } from 'firebase/storage';
-import { z } from 'zod';
+} from "firebase/firestore";
+import { z } from "zod";
 import {
   PatientProfile,
   CreatePatientProfileData,
@@ -26,43 +25,42 @@ import {
   SearchPatientsParams,
   RequesterInfo,
   PATIENTS_COLLECTION,
-} from '../../../types/patient';
+} from "../../../types/patient";
 import {
   patientProfileSchema,
   createPatientProfileSchema,
   searchPatientsSchema,
   requesterInfoSchema,
-} from '../../../validations/patient.schema';
+} 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>;
     } = {
       id: patientId,
       userRef: validatedData.userRef,
       displayName: validatedData.displayName,
-      profilePhoto: validatedData.profilePhoto || null,
       expoTokens: validatedData.expoTokens,
       gamification: validatedData.gamification || {
         level: 1,
@@ -93,16 +91,21 @@ 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
     }
 
@@ -111,21 +114,33 @@ 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
       }
     }
@@ -133,16 +148,23 @@ 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;
   }
@@ -150,7 +172,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;
@@ -158,7 +180,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);
@@ -173,7 +195,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),
@@ -184,7 +206,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),
@@ -195,10 +217,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(),
   });
 };
@@ -206,7 +228,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 = {
@@ -218,7 +240,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;
@@ -231,89 +253,24 @@ 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}`);
-  }
-};
-
-// Pomoćne funkcije za profilnu sliku
-export const uploadProfilePhotoUtil = async (
-  storage: FirebaseStorage,
-  patientId: string,
-  file: File,
-): Promise<string> => {
-  const photoRef = ref(storage, `patient-photos/${patientId}/profile-photo`);
-  await uploadBytes(photoRef, file);
-  return getDownloadURL(photoRef);
-};
-
-export const updateProfilePhotoUtil = async (
-  storage: FirebaseStorage,
-  db: Firestore,
-  patientId: string,
-  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');
-
-  const patientData = patientDoc.data() as PatientProfile;
-  if (patientData.profilePhoto) {
-    try {
-      const oldPhotoRef = ref(storage, patientData.profilePhoto);
-      await deleteObject(oldPhotoRef);
-    } catch (error) {
-      console.warn('Failed to delete old profile photo:', error);
-    }
-  }
-
-  // Zatim uploadujemo novu sliku
-  const newPhotoUrl = await uploadProfilePhotoUtil(storage, patientId, file);
-
-  // Ažuriramo profil sa novim URL-om
-  await updateDoc(getPatientDocRef(db, patientId), {
-    profilePhoto: newPhotoUrl,
-    updatedAt: serverTimestamp(),
-  });
-
-  return newPhotoUrl;
-};
-
-export const deleteProfilePhotoUtil = async (
-  storage: FirebaseStorage,
-  db: Firestore,
-  patientId: string,
-): Promise<void> => {
-  const patientDoc = await getDoc(getPatientDocRef(db, patientId));
-  if (!patientDoc.exists()) throw new Error('Patient profile not found');
-
-  const patientData = patientDoc.data() as PatientProfile;
-  if (patientData.profilePhoto) {
-    try {
-      const photoRef = ref(storage, patientData.profilePhoto);
-      await deleteObject(photoRef);
-    } catch (error) {
-      console.warn('Failed to delete profile photo:', error);
-    }
+    throw new Error(
+      `Failed to update patient profile by user ref: ${errorMessage}`
+    );
   }
-
-  await updateDoc(getPatientDocRef(db, patientId), {
-    profilePhoto: null,
-    updatedAt: serverTimestamp(),
-  });
 };
 
 /**
@@ -323,39 +280,45 @@ 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,
@@ -365,7 +328,9 @@ 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) {
@@ -386,7 +351,7 @@ export const testCreateSubDocuments = async (
 export const searchPatientsUtil = async (
   db: Firestore,
   params: SearchPatientsParams,
-  requester: RequesterInfo,
+  requester: RequesterInfo
 ): Promise<PatientProfile[]> => {
   // Validate input
   searchPatientsSchema.parse(params);
@@ -397,52 +362,65 @@ export const searchPatientsUtil = async (
 
   // --- Security Checks & Initial Filtering ---
 
-  if (requester.role === 'clinic_admin') {
+  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.');
+      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})`,
+        `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));
+    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));
+      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') {
+  } 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.');
+      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) {
+    if (
+      params.practitionerId &&
+      params.practitionerId !== requester.associatedPractitionerId
+    ) {
       console.warn(
-        `Practitioner (${requester.id}) attempted to search for patients of another practitioner (${params.practitionerId})`,
+        `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));
+    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));
+      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.');
+    throw new Error("Invalid requester role.");
   }
 
   // --- Execute Query ---
@@ -450,12 +428,16 @@ export const searchPatientsUtil = async (
     const finalQuery = query(patientsCollectionRef, ...constraints);
     const querySnapshot = await getDocs(finalQuery);
 
-    const patients = querySnapshot.docs.map((doc) => doc.data() as PatientProfile);
+    const patients = querySnapshot.docs.map(
+      (doc) => doc.data() as PatientProfile
+    );
 
-    console.log(`[searchPatientsUtil] Found ${patients.length} patients matching criteria.`);
+    console.log(
+      `[searchPatientsUtil] Found ${patients.length} patients matching criteria.`
+    );
     return patients;
   } catch (error) {
-    console.error('[searchPatientsUtil] Error searching patients:', 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
   }
@@ -472,10 +454,13 @@ export const searchPatientsUtil = async (
  */
 export const getAllPatientsUtil = async (
   db: Firestore,
-  options?: { limit?: number; startAfter?: string },
+  options?: { limit?: number; startAfter?: string }
 ): Promise<PatientProfile[]> => {
   try {
-    console.log(`[getAllPatientsUtil] Fetching patients with options:`, options);
+    console.log(
+      `[getAllPatientsUtil] Fetching patients with options:`,
+      options
+    );
 
     const patientsCollection = collection(db, PATIENTS_COLLECTION);
 
@@ -488,7 +473,9 @@ export const getAllPatientsUtil = async (
 
     // 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));
+      const startAfterDoc = await getDoc(
+        doc(db, PATIENTS_COLLECTION, options.startAfter)
+      );
       if (startAfterDoc.exists()) {
         q = query(q, startAfter(startAfterDoc));
       }
@@ -506,7 +493,9 @@ export const getAllPatientsUtil = async (
   } catch (error) {
     console.error(`[getAllPatientsUtil] Error fetching patients:`, error);
     throw new Error(
-      `Failed to retrieve patients: ${error instanceof Error ? error.message : String(error)}`,
+      `Failed to retrieve patients: ${
+        error instanceof Error ? error.message : String(error)
+      }`
     );
   }
 };

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

@@ -16,12 +16,54 @@ import {
   getSensitiveInfoDocRef,
   initSensitiveInfoDocIfNotExists,
 } from "./docs.utils";
+import {
+  MediaService,
+  MediaAccessLevel,
+  MediaResource,
+} from "../../media/media.service";
+
+/**
+ * Handles photoUrl upload for sensitive info (supports MediaResource)
+ * @param photoUrl - MediaResource (File, Blob, or URL string)
+ * @param patientId - ID of the patient
+ * @param mediaService - MediaService instance
+ * @returns URL string of the uploaded or existing photo
+ */
+const handlePhotoUrlUpload = async (
+  photoUrl: MediaResource | undefined | null,
+  patientId: string,
+  mediaService: MediaService
+): Promise<string | null> => {
+  if (!photoUrl) {
+    return null;
+  }
+
+  // If it's already a URL string, return it as is
+  if (typeof photoUrl === "string") {
+    return photoUrl;
+  }
+
+  // If it's a File or Blob, upload it
+  if (photoUrl instanceof File || photoUrl instanceof Blob) {
+    const mediaMetadata = await mediaService.uploadMedia(
+      photoUrl,
+      patientId, // Using patientId as ownerId
+      MediaAccessLevel.PRIVATE, // Sensitive info should be private
+      "patient_sensitive_photos",
+      photoUrl instanceof File ? photoUrl.name : `sensitive_photo_${patientId}`
+    );
+    return mediaMetadata.url;
+  }
+
+  return null;
+};
 
 // Funkcije za rad sa osetljivim informacijama
 export const createSensitiveInfoUtil = async (
   db: Firestore,
   data: CreatePatientSensitiveInfoData,
-  requesterUserId: string
+  requesterUserId: string,
+  mediaService?: MediaService
 ): Promise<PatientSensitiveInfo> => {
   try {
     if (data.userRef !== requesterUserId) {
@@ -38,8 +80,21 @@ export const createSensitiveInfoUtil = async (
       throw new Error("Sensitive information already exists for this patient");
     }
 
+    // Process photoUrl if it's a MediaResource and mediaService is provided
+    let processedPhotoUrl: string | null = null;
+    if (validatedData.photoUrl && mediaService) {
+      processedPhotoUrl = await handlePhotoUrlUpload(
+        validatedData.photoUrl,
+        data.patientId,
+        mediaService
+      );
+    } else if (typeof validatedData.photoUrl === "string") {
+      processedPhotoUrl = validatedData.photoUrl;
+    }
+
     const sensitiveInfoData = {
       ...validatedData,
+      photoUrl: processedPhotoUrl,
       createdAt: serverTimestamp(),
       updatedAt: serverTimestamp(),
     };
@@ -82,7 +137,8 @@ export const updateSensitiveInfoUtil = async (
   db: Firestore,
   patientId: string,
   data: UpdatePatientSensitiveInfoData,
-  requesterUserId: string
+  requesterUserId: string,
+  mediaService?: MediaService
 ): Promise<PatientSensitiveInfo> => {
   // if (data.userRef !== requesterUserId) {
   //   throw new Error("Only patient can update their sensitive information");
@@ -91,8 +147,26 @@ export const updateSensitiveInfoUtil = async (
   // Inicijalizacija dokumenta ako ne postoji
   await initSensitiveInfoDocIfNotExists(db, patientId, requesterUserId);
 
+  // Process photoUrl if it's a MediaResource and mediaService is provided
+  let processedPhotoUrl: string | null | undefined = undefined;
+  if (data.photoUrl !== undefined) {
+    if (mediaService) {
+      processedPhotoUrl = await handlePhotoUrlUpload(
+        data.photoUrl,
+        patientId,
+        mediaService
+      );
+    } else if (typeof data.photoUrl === "string" || data.photoUrl === null) {
+      processedPhotoUrl = data.photoUrl;
+    } else {
+      // If photoUrl is a File/Blob but no mediaService provided, throw error
+      throw new Error("MediaService required to process photo upload");
+    }
+  }
+
   const updateData = {
     ...data,
+    photoUrl: processedPhotoUrl,
     updatedAt: serverTimestamp(),
   };