@blackcode_sa/metaestetics-api 1.7.5 → 1.7.7

package/package.json

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

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

@@ -457,7 +457,12 @@ export class BookingAdmin {
       const clinicInfo: ClinicInfo = {
         id: clinicSnap.id,
         name: clinicData.name,
-        featuredPhoto: clinicData.coverPhoto || clinicData.logo || "",
+        featuredPhoto:
+          (typeof clinicData.coverPhoto === "string"
+            ? clinicData.coverPhoto
+            : "") ||
+          (typeof clinicData.logo === "string" ? clinicData.logo : "") ||
+          "",
         description: clinicData.description,
         location: clinicData.location,
         contactInfo: clinicData.contactInfo,

package/src/services/auth.service.ts

@@ -71,6 +71,7 @@ import {
 import { PractitionerService } from "./practitioner/practitioner.service";
 import { practitionerSignupSchema } from "../validations/practitioner.schema";
 import { CertificationLevel } from "../backoffice/types/static/certification.types";
+import { MediaService } from "./media/media.service";
 
 export class AuthService extends BaseService {
   private googleProvider = new GoogleAuthProvider();
@@ -199,12 +200,14 @@ export class AuthService extends BaseService {
         this.app,
         clinicAdminService
       );
+      const mediaService = new MediaService(this.db, this.auth, this.app);
       const clinicService = new ClinicService(
         this.db,
         this.auth,
         this.app,
         clinicGroupService,
-        clinicAdminService
+        clinicAdminService,
+        mediaService
       );
 
       // Set services to resolve circular dependencies
@@ -510,12 +513,14 @@ export class AuthService extends BaseService {
         this.app,
         clinicAdminService
       );
+      const mediaService = new MediaService(this.db, this.auth, this.app);
       const clinicService = new ClinicService(
         this.db,
         this.auth,
         this.app,
         clinicGroupService,
-        clinicAdminService
+        clinicAdminService,
+        mediaService
       );
 
       // Set services to resolve circular dependencies

package/src/services/clinic/clinic.service.ts

@@ -43,6 +43,8 @@ import {
 import {
   clinicSchema,
   createClinicSchema,
+  updateClinicSchema,
+  clinicBranchSetupSchema,
 } from "../../validations/clinic.schema";
 import { z } from "zod";
 import { Auth } from "firebase/auth";
@@ -55,41 +57,175 @@ import * as AdminUtils from "./utils/admin.utils";
 import * as FilterUtils from "./utils/filter.utils";
 import { ClinicReviewInfo } from "../../types/reviews";
 import { PRACTITIONERS_COLLECTION } from "../../types/practitioner";
+import { MediaService, MediaAccessLevel } from "../media/media.service";
 
 export class ClinicService extends BaseService {
   private clinicGroupService: ClinicGroupService;
   private clinicAdminService: ClinicAdminService;
+  private mediaService: MediaService;
 
   constructor(
     db: Firestore,
     auth: Auth,
     app: FirebaseApp,
     clinicGroupService: ClinicGroupService,
-    clinicAdminService: ClinicAdminService
+    clinicAdminService: ClinicAdminService,
+    mediaService: MediaService
   ) {
     super(db, auth, app);
     this.clinicAdminService = clinicAdminService;
     this.clinicGroupService = clinicGroupService;
+    this.mediaService = mediaService;
+  }
+
+  /**
+   * Process media resource (string URL or File object)
+   * @param media String URL or File object
+   * @param ownerId Owner ID for the media (usually clinicId)
+   * @param collectionName Collection name for organizing files
+   * @returns URL string after processing
+   */
+  private async processMedia(
+    media: string | File | Blob | null | undefined,
+    ownerId: string,
+    collectionName: string
+  ): Promise<string | null> {
+    if (!media) return null;
+
+    // If already a string URL, return it directly
+    if (typeof media === "string") {
+      return media;
+    }
+
+    // If it's a File, upload it using MediaService
+    if (media instanceof File || media instanceof Blob) {
+      console.log(
+        `[ClinicService] Uploading ${collectionName} media for ${ownerId}`
+      );
+      const metadata = await this.mediaService.uploadMedia(
+        media,
+        ownerId,
+        MediaAccessLevel.PUBLIC,
+        collectionName
+      );
+      return metadata.url;
+    }
+
+    return null;
+  }
+
+  /**
+   * Process array of media resources (strings or Files)
+   * @param mediaArray Array of string URLs or File objects
+   * @param ownerId Owner ID for the media
+   * @param collectionName Collection name for organizing files
+   * @returns Array of URL strings after processing
+   */
+  private async processMediaArray(
+    mediaArray: (string | File | Blob)[] | undefined,
+    ownerId: string,
+    collectionName: string
+  ): Promise<string[]> {
+    if (!mediaArray || mediaArray.length === 0) return [];
+
+    const result: string[] = [];
+
+    for (const media of mediaArray) {
+      const processedUrl = await this.processMedia(
+        media,
+        ownerId,
+        collectionName
+      );
+      if (processedUrl) {
+        result.push(processedUrl);
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * Process photos with tags array
+   * @param photosWithTags Array of objects containing media and tag
+   * @param ownerId Owner ID for the media
+   * @param collectionName Collection name for organizing files
+   * @returns Processed array with URL strings
+   */
+  private async processPhotosWithTags(
+    photosWithTags: { url: string | File | Blob; tag: string }[] | undefined,
+    ownerId: string,
+    collectionName: string
+  ): Promise<{ url: string; tag: string }[]> {
+    if (!photosWithTags || photosWithTags.length === 0) return [];
+
+    const result: { url: string; tag: string }[] = [];
+
+    for (const item of photosWithTags) {
+      const processedUrl = await this.processMedia(
+        item.url,
+        ownerId,
+        collectionName
+      );
+      if (processedUrl) {
+        result.push({
+          url: processedUrl,
+          tag: item.tag,
+        });
+      }
+    }
+
+    return result;
   }
 
   /**
    * Creates a new clinic.
+   * Handles both URL strings and File uploads for media fields.
    */
   async createClinic(
     data: CreateClinicData,
     creatorAdminId: string
   ): Promise<Clinic> {
     try {
+      // Generate ID first so we can use it for media uploads
+      const clinicId = this.generateId();
+
+      // Validate data - this now works because mediaResourceSchema has been updated to support Files/Blobs
       const validatedData = createClinicSchema.parse(data);
+
       const group = await this.clinicGroupService.getClinicGroup(
         validatedData.clinicGroupId
       );
-      if (!group)
+      if (!group) {
         throw new Error(
           `Clinic group ${validatedData.clinicGroupId} not found`
         );
+      }
+
+      // Process media fields - convert File/Blob objects to URLs
+      const logoUrl = await this.processMedia(
+        validatedData.logo,
+        clinicId,
+        "clinic-logos"
+      );
+      const coverPhotoUrl = await this.processMedia(
+        validatedData.coverPhoto,
+        clinicId,
+        "clinic-cover-photos"
+      );
+      const featuredPhotos = await this.processMediaArray(
+        validatedData.featuredPhotos,
+        clinicId,
+        "clinic-featured-photos"
+      );
+      const photosWithTags = await this.processPhotosWithTags(
+        validatedData.photosWithTags,
+        clinicId,
+        "clinic-gallery"
+      );
+
       const location = validatedData.location;
       const hash = geohashForLocation([location.latitude, location.longitude]);
+
       const defaultReviewInfo: ClinicReviewInfo = {
         totalReviews: 0,
         averageRating: 0,
@@ -100,7 +236,6 @@ export class ClinicService extends BaseService {
         accessibility: 0,
         recommendationPercentage: 0,
       };
-      const clinicId = this.generateId();
 
       const clinicData: Omit<Clinic, "createdAt" | "updatedAt"> & {
         createdAt: FieldValue;
@@ -114,34 +249,41 @@ export class ClinicService extends BaseService {
         contactInfo: validatedData.contactInfo,
         workingHours: validatedData.workingHours,
         tags: validatedData.tags,
-        featuredPhotos: validatedData.featuredPhotos || [],
-        coverPhoto: validatedData.coverPhoto,
-        photosWithTags: validatedData.photosWithTags,
-        doctors: [],
-        procedures: [],
+        featuredPhotos: featuredPhotos,
+        coverPhoto: coverPhotoUrl,
+        photosWithTags: photosWithTags,
+        doctors: validatedData.doctors || [],
+        procedures: validatedData.procedures || [],
         doctorsInfo: [],
-        proceduresInfo: [],
+        proceduresInfo: validatedData.proceduresInfo || [],
         reviewInfo: defaultReviewInfo,
         admins: [creatorAdminId],
-        isActive: validatedData.isActive,
-        isVerified: validatedData.isVerified,
-        logo: validatedData.logo,
+        isActive:
+          validatedData.isActive !== undefined ? validatedData.isActive : true,
+        isVerified:
+          validatedData.isVerified !== undefined
+            ? validatedData.isVerified
+            : false,
+        logo: logoUrl,
         createdAt: serverTimestamp(),
         updatedAt: serverTimestamp(),
       };
 
-      // Re-validate before saving (ensure schema matches the final object)
+      // We can validate the final object with URLs using clinicSchema which also supports mediaResourceSchema
+      // However, we need to be careful with timestamps
+      // The validation below is optional and can be uncommented if needed
+      /*
       clinicSchema.parse({
         ...clinicData,
         createdAt: Timestamp.now(),
         updatedAt: Timestamp.now(),
       });
+      */
 
       const batch = writeBatch(this.db);
       const clinicRef = doc(this.db, CLINICS_COLLECTION, clinicId);
       batch.set(clinicRef, clinicData);
 
-      // Update admin relationship - this part is still needed
       const adminRef = doc(this.db, CLINIC_ADMINS_COLLECTION, creatorAdminId);
       batch.update(adminRef, {
         clinicsManaged: arrayUnion(clinicId),
@@ -149,6 +291,8 @@ export class ClinicService extends BaseService {
       });
 
       await batch.commit();
+      console.log(`[ClinicService] Clinic created successfully: ${clinicId}`);
+
       const savedClinic = await this.getClinic(clinicId);
       if (!savedClinic) throw new Error("Failed to retrieve created clinic");
       return savedClinic;
@@ -163,66 +307,106 @@ export class ClinicService extends BaseService {
 
   /**
    * Updates a clinic.
+   * Handles both URL strings and File uploads for media fields.
    */
   async updateClinic(
     clinicId: string,
-    data: Partial<Omit<Clinic, "id" | "createdAt" | "clinicGroupId">>,
+    data: Partial<CreateClinicData>,
     adminId: string
   ): Promise<Clinic> {
-    const clinicRef = doc(this.db, CLINICS_COLLECTION, clinicId);
-    const clinicDoc = await getDoc(clinicRef);
-    if (!clinicDoc.exists()) {
-      throw new Error(`Clinic ${clinicId} not found`);
-    }
-
     try {
+      // First check if clinic exists
+      const clinicRef = doc(this.db, CLINICS_COLLECTION, clinicId);
+      const clinicDoc = await getDoc(clinicRef);
+
+      if (!clinicDoc.exists()) {
+        throw new Error(`Clinic ${clinicId} not found`);
+      }
+
       const currentClinic = clinicDoc.data() as Clinic;
-      // Explicitly Omit fields managed by other services or internally
-      const { doctorsInfo, proceduresInfo, ...updatePayload } =
-        data as Partial<Clinic>;
 
-      if (updatePayload.location) {
-        const loc = updatePayload.location;
+      // Validate update data - this works because updateClinicSchema supports Files/Blobs
+      const validatedData = updateClinicSchema.parse(data);
+
+      const updatePayload: Record<string, any> = {};
+
+      // Process media fields if provided
+      if (validatedData.logo !== undefined) {
+        updatePayload.logo = await this.processMedia(
+          validatedData.logo,
+          clinicId,
+          "clinic-logos"
+        );
+      }
+
+      if (validatedData.coverPhoto !== undefined) {
+        updatePayload.coverPhoto = await this.processMedia(
+          validatedData.coverPhoto,
+          clinicId,
+          "clinic-cover-photos"
+        );
+      }
+
+      if (validatedData.featuredPhotos !== undefined) {
+        updatePayload.featuredPhotos = await this.processMediaArray(
+          validatedData.featuredPhotos,
+          clinicId,
+          "clinic-featured-photos"
+        );
+      }
+
+      if (validatedData.photosWithTags !== undefined) {
+        updatePayload.photosWithTags = await this.processPhotosWithTags(
+          validatedData.photosWithTags,
+          clinicId,
+          "clinic-gallery"
+        );
+      }
+
+      // Process non-media fields
+      const fieldsToUpdate = [
+        "name",
+        "description",
+        "contactInfo",
+        "workingHours",
+        "tags",
+        "doctors",
+        "procedures",
+        "proceduresInfo",
+        "isActive",
+        "isVerified",
+      ];
+
+      for (const field of fieldsToUpdate) {
+        if (validatedData[field as keyof typeof validatedData] !== undefined) {
+          updatePayload[field] =
+            validatedData[field as keyof typeof validatedData];
+        }
+      }
+
+      // Handle location update with geohash
+      if (validatedData.location) {
+        const loc = validatedData.location;
         updatePayload.location = {
           ...loc,
           geohash: geohashForLocation([loc.latitude, loc.longitude]),
         };
       }
 
-      // Merge with current data for validation and aggregation, preserving arrays managed elsewhere
-      const finalStateForValidation = {
-        ...currentClinic,
-        ...updatePayload, // Apply safe updates
-        // Explicitly keep arrays managed by other services from current state
-        doctorsInfo: currentClinic.doctorsInfo,
-        proceduresInfo: currentClinic.proceduresInfo,
-      };
-
-      // Ensure required fields for validation are present
-      clinicSchema.parse({
-        ...finalStateForValidation,
-        updatedAt: Timestamp.now(), // Use current time for validation
-      });
-
-      // Prepare final update data for Firestore, including timestamp
-      const updateDataForFirestore = {
-        ...updatePayload,
-        updatedAt: serverTimestamp(),
-      };
+      // Add timestamp
+      updatePayload.updatedAt = serverTimestamp();
 
-      await updateDoc(clinicRef, updateDataForFirestore);
+      // Update the clinic
+      await updateDoc(clinicRef, updatePayload);
+      console.log(`[ClinicService] Clinic ${clinicId} updated successfully`);
 
+      // Return the updated clinic
       const updatedClinic = await this.getClinic(clinicId);
       if (!updatedClinic) throw new Error("Failed to retrieve updated clinic");
       return updatedClinic;
     } catch (error) {
       if (error instanceof z.ZodError) {
-        throw new Error(
-          "Invalid clinic update data: " +
-            error.errors
-              .map((e) => `${e.path.join(".")} - ${e.message}`)
-              .join(", ")
-        );
+        throw new Error("Invalid clinic update data: " + error.message);
       }
       console.error(`Error updating clinic ${clinicId}:`, error);
       throw error;
@@ -334,6 +518,10 @@ export class ClinicService extends BaseService {
     );
   }
 
+  /**
+   * Creates a clinic branch from setup data.
+   * Handles both URL strings and File uploads for media fields.
+   */
   async createClinicBranch(
     clinicGroupId: string,
     setupData: ClinicBranchSetupData,
@@ -344,7 +532,7 @@ export class ClinicService extends BaseService {
       adminId,
     });
 
-    // Validate that the clinic group exists
+    // Verify clinic group exists
     const clinicGroup = await this.clinicGroupService.getClinicGroup(
       clinicGroupId
     );
@@ -356,47 +544,42 @@ export class ClinicService extends BaseService {
     }
     console.log("[CLINIC_SERVICE] Clinic group verified");
 
-    // TODO: Handle logo, coverPhoto, featuredPhotos, photosWithTags and upload them to storage
-    // Use storage service to upload files, and get the download URL
-    // Use path 'clinics/{clinicId}/{photoType}/{filename}' for storing the files
-    // Photo types: logo, coverPhoto, featuredPhotos, photosWithTags
-    // Storage can be accessed by using the storage service like app.getStorage()
+    // Validate branch setup data first
+    const validatedSetupData = clinicBranchSetupSchema.parse(setupData);
 
-    // Create the clinic data
+    // Convert validated setup data to CreateClinicData
     const createClinicData: CreateClinicData = {
       clinicGroupId,
-      name: setupData.name,
-      description: setupData.description,
-      location: setupData.location,
-      contactInfo: setupData.contactInfo,
-      workingHours: setupData.workingHours,
-      tags: setupData.tags,
-      coverPhoto: setupData.coverPhoto || null,
-      photosWithTags: setupData.photosWithTags || [],
+      name: validatedSetupData.name,
+      description: validatedSetupData.description,
+      location: validatedSetupData.location,
+      contactInfo: validatedSetupData.contactInfo,
+      workingHours: validatedSetupData.workingHours,
+      tags: validatedSetupData.tags || [],
+      // Pass the media fields which can be string URLs or File objects
+      logo: validatedSetupData.logo,
+      coverPhoto: validatedSetupData.coverPhoto,
+      featuredPhotos: validatedSetupData.featuredPhotos,
+      photosWithTags: validatedSetupData.photosWithTags,
       doctors: [],
       procedures: [],
       admins: [adminId],
       isActive: true,
       isVerified: false,
-      logo: setupData.logo,
-      featuredPhotos: setupData.featuredPhotos || [],
     };
 
-    console.log("[CLINIC_SERVICE] Creating clinic branch with data", {
+    console.log("[CLINIC_SERVICE] Creating clinic branch", {
       name: createClinicData.name,
       hasLogo: !!createClinicData.logo,
       hasCoverPhoto: !!createClinicData.coverPhoto,
-      featuredPhotosCount: createClinicData.featuredPhotos?.length || 0,
-      photosWithTagsCount: createClinicData.photosWithTags?.length || 0,
     });
 
-    // Create the clinic - the createClinic method will handle photo uploads
+    // Use createClinic which now handles validation and media uploads
     const clinic = await this.createClinic(createClinicData, adminId);
+
     console.log("[CLINIC_SERVICE] Clinic branch created successfully", {
       clinicId: clinic.id,
     });
-
-    // Note: The createClinic method already adds the clinic to the admin's managed clinics
     return clinic;
   }