@blackcode_sa/metaestetics-api 1.7.19 → 1.7.21

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@blackcode_sa/metaestetics-api",
   "private": false,
-  "version": "1.7.19",
+  "version": "1.7.21",
   "description": "Firebase authentication service with anonymous upgrade support",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",

package/src/admin/booking/booking.admin.ts

@@ -613,7 +613,10 @@ export class BookingAdmin {
       };
       const practitionerInfo: PractitionerProfileInfo = {
         id: practitionerSnap.id,
-        practitionerPhoto: practitionerData.basicInfo.profileImageUrl || null,
+        practitionerPhoto:
+          typeof practitionerData.basicInfo.profileImageUrl === "string"
+            ? practitionerData.basicInfo.profileImageUrl
+            : null,
         name: `${practitionerData.basicInfo.firstName} ${practitionerData.basicInfo.lastName}`,
         email: practitionerData.basicInfo.email,
         phone: practitionerData.basicInfo.phoneNumber || null,

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

@@ -7,6 +7,11 @@ import {
   serverTimestamp,
 } from "firebase/firestore";
 import { BaseService } from "../base.service";
+import {
+  MediaService,
+  MediaAccessLevel,
+  MediaResource,
+} from "../media/media.service";
 import {
   PatientProfile,
   PatientSensitiveInfo,
@@ -46,9 +51,6 @@ import {
   addExpoTokenUtil,
   removeExpoTokenUtil,
   addPointsUtil,
-  uploadProfilePhotoUtil,
-  updateProfilePhotoUtil,
-  deleteProfilePhotoUtil,
   updatePatientProfileUtil,
   updatePatientProfileByUserRefUtil,
   searchPatientsUtil,
@@ -107,8 +109,11 @@ import {
 import { getPatientsByClinicUtil } from "./utils/clinic.utils";
 
 export class PatientService extends BaseService {
+  private mediaService: MediaService;
+
   constructor(db: Firestore, auth: Auth, app: FirebaseApp) {
     super(db, auth, app);
+    this.mediaService = new MediaService(db, auth, app);
   }
 
   // Metode za rad sa profilom pacijenta
@@ -183,7 +188,12 @@ export class PatientService extends BaseService {
     data: CreatePatientSensitiveInfoData,
     requesterUserId: string
   ): Promise<PatientSensitiveInfo> {
-    return createSensitiveInfoUtil(this.db, data, requesterUserId);
+    return createSensitiveInfoUtil(
+      this.db,
+      data,
+      requesterUserId,
+      this.mediaService
+    );
   }
 
   async getSensitiveInfo(
@@ -207,7 +217,13 @@ export class PatientService extends BaseService {
     data: UpdatePatientSensitiveInfoData,
     requesterUserId: string
   ): Promise<PatientSensitiveInfo> {
-    return updateSensitiveInfoUtil(this.db, patientId, data, requesterUserId);
+    return updateSensitiveInfoUtil(
+      this.db,
+      patientId,
+      data,
+      requesterUserId,
+      this.mediaService
+    );
   }
 
   // Metode za rad sa medicinskim informacijama
@@ -453,16 +469,152 @@ export class PatientService extends BaseService {
   }
 
   // Metode za rad sa profilnom slikom
-  async uploadProfilePhoto(patientId: string, file: File): Promise<string> {
-    return uploadProfilePhotoUtil(this.storage, patientId, file);
+  /**
+   * Uploads a profile photo for a patient
+   * @param patientId - ID of the patient
+   * @param file - File or Blob to upload
+   * @returns URL of the uploaded photo
+   */
+  async uploadProfilePhoto(
+    patientId: string,
+    file: File | Blob
+  ): Promise<string> {
+    console.log(
+      `[PatientService] Uploading profile photo for patient ${patientId}`
+    );
+
+    const mediaMetadata = await this.mediaService.uploadMedia(
+      file,
+      patientId, // Using patientId as ownerId
+      MediaAccessLevel.PRIVATE, // Profile photos should be private
+      "patient_profile_photos",
+      file instanceof File ? file.name : `profile_photo_${patientId}`
+    );
+
+    // Update the patient sensitive info with the new photo URL
+    await updateDoc(getSensitiveInfoDocRef(this.db, patientId), {
+      photoUrl: mediaMetadata.url,
+      updatedAt: serverTimestamp(),
+    });
+
+    return mediaMetadata.url;
   }
 
-  async updateProfilePhoto(patientId: string, file: File): Promise<string> {
-    return updateProfilePhotoUtil(this.storage, this.db, patientId, file);
+  /**
+   * Updates a patient's profile photo (replaces existing one)
+   * @param patientId - ID of the patient
+   * @param file - New file or Blob to upload
+   * @returns URL of the new uploaded photo
+   */
+  async updateProfilePhoto(
+    patientId: string,
+    file: File | Blob
+  ): Promise<string> {
+    console.log(
+      `[PatientService] Updating profile photo for patient ${patientId}`
+    );
+
+    // Get current patient sensitive info to check for existing photo
+    const currentUser = await this.getCurrentUser();
+    const currentSensitiveInfo = await this.getSensitiveInfo(
+      patientId,
+      currentUser.uid
+    );
+
+    // Delete old photo if it exists and is managed by our MediaService
+    if (
+      currentSensitiveInfo?.photoUrl &&
+      typeof currentSensitiveInfo.photoUrl === "string"
+    ) {
+      try {
+        const existingMediaMetadata =
+          await this.mediaService.getMediaMetadataByUrl(
+            currentSensitiveInfo.photoUrl
+          );
+        if (existingMediaMetadata) {
+          await this.mediaService.deleteMedia(existingMediaMetadata.id);
+        }
+      } catch (error) {
+        console.warn(
+          `[PatientService] Could not delete old profile photo for patient ${patientId}:`,
+          error
+        );
+        // Continue with upload even if deletion fails
+      }
+    }
+
+    // Upload new photo
+    return this.uploadProfilePhoto(patientId, file);
   }
 
+  /**
+   * Deletes a patient's profile photo
+   * @param patientId - ID of the patient
+   */
   async deleteProfilePhoto(patientId: string): Promise<void> {
-    await deleteProfilePhotoUtil(this.storage, this.db, patientId);
+    console.log(
+      `[PatientService] Deleting profile photo for patient ${patientId}`
+    );
+
+    // Get current patient sensitive info to find the photo URL
+    const currentUser = await this.getCurrentUser();
+    const currentSensitiveInfo = await this.getSensitiveInfo(
+      patientId,
+      currentUser.uid
+    );
+
+    if (
+      currentSensitiveInfo?.photoUrl &&
+      typeof currentSensitiveInfo.photoUrl === "string"
+    ) {
+      try {
+        const existingMediaMetadata =
+          await this.mediaService.getMediaMetadataByUrl(
+            currentSensitiveInfo.photoUrl
+          );
+        if (existingMediaMetadata) {
+          await this.mediaService.deleteMedia(existingMediaMetadata.id);
+        }
+      } catch (error) {
+        console.warn(
+          `[PatientService] Could not delete profile photo for patient ${patientId}:`,
+          error
+        );
+      }
+
+      // Remove photo URL from patient sensitive info
+      await updateDoc(getSensitiveInfoDocRef(this.db, patientId), {
+        photoUrl: null,
+        updatedAt: serverTimestamp(),
+      });
+    }
+  }
+
+  /**
+   * Handles profile photo upload for patients (supports MediaResource)
+   * @param photoUrl - MediaResource (File, Blob, or URL string) from CreatePatientSensitiveInfoData
+   * @param patientId - ID of the patient
+   * @returns URL string of the uploaded or existing photo
+   */
+  private async handleProfilePhotoUpload(
+    photoUrl: MediaResource | undefined,
+    patientId: string
+  ): Promise<string | undefined> {
+    if (!photoUrl) {
+      return undefined;
+    }
+
+    // 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) {
+      return this.uploadProfilePhoto(patientId, photoUrl);
+    }
+
+    return undefined;
   }
 
   // Metode za ažuriranje profila