@blackcode_sa/metaestetics-api 1.4.8 → 1.4.10

package/src/services/clinic/utils/clinic.utils.ts

@@ -11,6 +11,8 @@ import {
   Timestamp,
   Firestore,
   QueryConstraint,
+  addDoc,
+  writeBatch,
 } from "firebase/firestore";
 import {
   Clinic,
@@ -19,6 +21,8 @@ import {
   ClinicReview,
   ClinicTag,
   ClinicGroup,
+  ClinicBranchSetupData,
+  ClinicLocation,
 } from "../../../types/clinic";
 import { geohashForLocation } from "geofire-common";
 import {
@@ -27,6 +31,12 @@ import {
   clinicReviewSchema,
 } from "../../../validations/clinic.schema";
 import { z } from "zod";
+import { FirebaseApp } from "firebase/app";
+import {
+  uploadPhoto,
+  uploadMultiplePhotos,
+  processEntityPhotos,
+} from "./photos.utils";
 
 /**
  * Creates a new clinic
@@ -35,6 +45,7 @@ import { z } from "zod";
  * @param creatorAdminId - ID of the admin creating the clinic
  * @param clinicGroupService - Service for clinic group operations
  * @param clinicAdminService - Service for clinic admin operations
+ * @param app - Firebase app instance
  * @returns The created clinic
  */
 export async function createClinic(
@@ -42,55 +53,224 @@ export async function createClinic(
   data: CreateClinicData,
   creatorAdminId: string,
   clinicGroupService: any,
-  clinicAdminService: any
+  clinicAdminService: any,
+  app: FirebaseApp
 ): Promise<Clinic> {
+  console.log("[CLINIC] Starting clinic creation", { creatorAdminId });
+  console.log("[CLINIC] Input data:", JSON.stringify(data, null, 2));
+
   // Validacija podataka
+  try {
+    const validatedData = createClinicSchema.parse(data);
+    console.log("[CLINIC] Data validation passed");
+  } catch (validationError) {
+    console.error("[CLINIC] Data validation failed:", validationError);
+    throw validationError;
+  }
+
   const validatedData = createClinicSchema.parse(data);
 
   // Proveravamo da li admin postoji i da li pripada grupi
-  const admin = await clinicAdminService.getClinicAdmin(creatorAdminId);
-  if (!admin) {
-    throw new Error("Admin not found");
-  }
+  try {
+    console.log("[CLINIC] Checking if admin exists and belongs to group");
+    const admin = await clinicAdminService.getClinicAdmin(creatorAdminId);
+    if (!admin) {
+      console.error("[CLINIC] Admin not found", { creatorAdminId });
+      throw new Error("Admin not found");
+    }
 
-  if (admin.clinicGroupId !== validatedData.clinicGroupId) {
-    throw new Error("Admin does not belong to this clinic group");
+    if (admin.clinicGroupId !== validatedData.clinicGroupId) {
+      console.error("[CLINIC] Admin does not belong to this clinic group", {
+        adminGroupId: admin.clinicGroupId,
+        requestedGroupId: validatedData.clinicGroupId,
+      });
+      throw new Error("Admin does not belong to this clinic group");
+    }
+    console.log("[CLINIC] Admin verified");
+  } catch (adminError) {
+    console.error("[CLINIC] Error verifying admin:", adminError);
+    throw adminError;
   }
 
   // Proveravamo da li grupa postoji
-  const group = await clinicGroupService.getClinicGroup(
-    validatedData.clinicGroupId
-  );
-  if (!group) {
-    throw new Error("Clinic group not found");
+  try {
+    console.log("[CLINIC] Checking if clinic group exists");
+    const group = await clinicGroupService.getClinicGroup(
+      validatedData.clinicGroupId
+    );
+    if (!group) {
+      console.error("[CLINIC] Clinic group not found", {
+        groupId: validatedData.clinicGroupId,
+      });
+      throw new Error("Clinic group not found");
+    }
+    console.log("[CLINIC] Clinic group verified");
+  } catch (groupError) {
+    console.error("[CLINIC] Error verifying clinic group:", groupError);
+    throw groupError;
   }
 
   // Generišemo geohash za lokaciju
+  console.log("[CLINIC] Generating geohash for location");
   if (validatedData.location) {
-    validatedData.location.geohash = geohashForLocation([
-      validatedData.location.latitude,
-      validatedData.location.longitude,
-    ]);
+    try {
+      validatedData.location.geohash = geohashForLocation([
+        validatedData.location.latitude,
+        validatedData.location.longitude,
+      ]);
+      console.log("[CLINIC] Geohash generated successfully", {
+        geohash: validatedData.location.geohash,
+      });
+    } catch (geohashError) {
+      console.error("[CLINIC] Error generating geohash:", geohashError);
+      throw geohashError;
+    }
+  }
+
+  // Generate a unique ID for the clinic
+  const clinicId = doc(collection(db, CLINICS_COLLECTION)).id;
+  console.log("[CLINIC] Generated clinic ID:", clinicId);
+
+  // Process photos
+  console.log("[CLINIC] Processing photos");
+
+  // Handle logo upload if provided
+  let logoUrl = null;
+  if (validatedData.logo) {
+    console.log("[CLINIC] Processing logo");
+    try {
+      logoUrl = await uploadPhoto(
+        validatedData.logo,
+        "clinics",
+        clinicId,
+        "logo",
+        app
+      );
+      console.log("[CLINIC] Logo processed", { logoUrl });
+    } catch (logoError) {
+      console.error("[CLINIC] Error processing logo:", logoError);
+      // Continue with clinic creation even if logo upload fails
+    }
+  }
+
+  // Handle regular photos upload
+  let processedPhotos: string[] = [];
+  if (validatedData.photos && validatedData.photos.length > 0) {
+    console.log("[CLINIC] Processing regular photos");
+    try {
+      processedPhotos = await uploadMultiplePhotos(
+        validatedData.photos,
+        "clinics",
+        clinicId,
+        "photo",
+        app
+      );
+      console.log("[CLINIC] Regular photos processed", {
+        count: processedPhotos.length,
+      });
+    } catch (photosError) {
+      console.error("[CLINIC] Error processing regular photos:", photosError);
+      // Continue with clinic creation even if photos upload fails
+      processedPhotos = validatedData.photos.filter(
+        (photo) => !photo.startsWith("data:")
+      );
+    }
+  }
+
+  // Handle featured photos upload
+  let processedFeaturedPhotos: string[] = [];
+  if (validatedData.featuredPhotos && validatedData.featuredPhotos.length > 0) {
+    console.log("[CLINIC] Processing featured photos");
+    try {
+      processedFeaturedPhotos = await uploadMultiplePhotos(
+        validatedData.featuredPhotos,
+        "clinics",
+        clinicId,
+        "featured",
+        app
+      );
+      console.log("[CLINIC] Featured photos processed", {
+        count: processedFeaturedPhotos.length,
+      });
+    } catch (featuredError) {
+      console.error(
+        "[CLINIC] Error processing featured photos:",
+        featuredError
+      );
+      // Continue with clinic creation even if featured photos upload fails
+      processedFeaturedPhotos = validatedData.featuredPhotos.filter(
+        (photo) => !photo.startsWith("data:")
+      );
+    }
+  }
+
+  // Handle photos with tags
+  let processedPhotosWithTags = validatedData.photosWithTags || [];
+  if (processedPhotosWithTags.length > 0) {
+    console.log("[CLINIC] Processing photos with tags");
+    try {
+      const updatedPhotosWithTags = [];
+      for (const photoWithTag of processedPhotosWithTags) {
+        if (photoWithTag.url && photoWithTag.url.startsWith("data:")) {
+          const uploadedUrl = await uploadPhoto(
+            photoWithTag.url,
+            "clinics",
+            clinicId,
+            `tagged-${photoWithTag.tag}`,
+            app
+          );
+          if (uploadedUrl) {
+            updatedPhotosWithTags.push({
+              url: uploadedUrl,
+              tag: photoWithTag.tag,
+            });
+          }
+        } else {
+          updatedPhotosWithTags.push(photoWithTag);
+        }
+      }
+      processedPhotosWithTags = updatedPhotosWithTags;
+      console.log("[CLINIC] Photos with tags processed", {
+        count: processedPhotosWithTags.length,
+      });
+    } catch (tagsError) {
+      console.error("[CLINIC] Error processing photos with tags:", tagsError);
+      // Continue with clinic creation even if photos with tags upload fails
+      processedPhotosWithTags =
+        validatedData.photosWithTags?.filter(
+          (photo) => !photo.url.startsWith("data:")
+        ) || [];
+    }
   }
 
   const now = Timestamp.now();
+  console.log("[CLINIC] Preparing clinic data object");
+
   const clinicData: Clinic = {
     ...validatedData,
-    id: doc(collection(db, CLINICS_COLLECTION)).id,
+    id: clinicId,
     description: validatedData.description || undefined,
     location: {
-      ...validatedData.location,
+      address: validatedData.location.address || "",
+      city: validatedData.location.city || "",
+      country: validatedData.location.country || "",
+      postalCode: validatedData.location.postalCode || "",
+      latitude: validatedData.location.latitude || 0,
+      longitude: validatedData.location.longitude || 0,
       geohash: validatedData.location.geohash || undefined,
     },
     contactInfo: {
-      ...validatedData.contactInfo,
+      email: validatedData.contactInfo.email || "",
+      phoneNumber: validatedData.contactInfo.phoneNumber || "",
       alternativePhoneNumber:
         validatedData.contactInfo.alternativePhoneNumber || undefined,
       website: validatedData.contactInfo.website || undefined,
     },
+    logo: logoUrl || undefined,
     tags: validatedData.tags || [],
-    featuredPhotos: [],
-    photos: validatedData.photos || [],
+    featuredPhotos: processedFeaturedPhotos || [],
+    photos: processedPhotos || [],
+    photosWithTags: processedPhotosWithTags,
     doctors: [],
     doctorsInfo: [],
     services: [],
@@ -107,24 +287,82 @@ export async function createClinic(
 
   try {
     // Validiramo kompletan objekat
-    clinicSchema.parse(clinicData);
+    console.log("[CLINIC] Validating complete clinic object");
+    try {
+      clinicSchema.parse(clinicData);
+      console.log("[CLINIC] Clinic validation passed");
+    } catch (schemaError) {
+      console.error(
+        "[CLINIC] Clinic validation failed:",
+        JSON.stringify(schemaError, null, 2)
+      );
+      throw schemaError;
+    }
 
     // Čuvamo u Firestore
-    await setDoc(doc(db, CLINICS_COLLECTION, clinicData.id), clinicData);
+    console.log("[CLINIC] Saving clinic to Firestore", {
+      clinicId: clinicData.id,
+    });
+    try {
+      await setDoc(doc(db, CLINICS_COLLECTION, clinicData.id), clinicData);
+      console.log("[CLINIC] Clinic saved successfully");
+    } catch (firestoreError) {
+      console.error("[CLINIC] Error saving to Firestore:", firestoreError);
+      throw firestoreError;
+    }
 
     // Dodajemo kliniku u grupaciju
-    await clinicGroupService.updateClinicGroup(validatedData.clinicGroupId, {
-      clinics: [...group.clinics, clinicData.id],
-    });
+    console.log("[CLINIC] Adding clinic to clinic group");
+    try {
+      const group = await clinicGroupService.getClinicGroup(
+        validatedData.clinicGroupId
+      );
+      if (group) {
+        await clinicGroupService.updateClinicGroup(
+          validatedData.clinicGroupId,
+          {
+            clinics: [...group.clinics, clinicData.id],
+          }
+        );
+        console.log("[CLINIC] Clinic added to group successfully");
+      }
+    } catch (groupUpdateError) {
+      console.error("[CLINIC] Error adding clinic to group:", groupUpdateError);
+      // Continue even if adding to group fails
+    }
 
     // Dodajemo kliniku adminu koji ju je kreirao
-    await clinicAdminService.addClinicToManaged(creatorAdminId, clinicData.id);
+    console.log("[CLINIC] Adding clinic to admin's managed clinics");
+    try {
+      await clinicAdminService.addClinicToManaged(
+        creatorAdminId,
+        clinicData.id
+      );
+      console.log(
+        "[CLINIC] Clinic added to admin's managed clinics successfully"
+      );
+    } catch (adminUpdateError) {
+      console.error(
+        "[CLINIC] Error adding clinic to admin's managed clinics:",
+        adminUpdateError
+      );
+      // Continue even if adding to admin fails
+    }
 
+    console.log("[CLINIC] Clinic creation completed successfully", {
+      clinicId: clinicData.id,
+      clinicName: clinicData.name,
+    });
     return clinicData;
   } catch (error) {
     if (error instanceof z.ZodError) {
+      console.error(
+        "[CLINIC] Zod validation error:",
+        JSON.stringify(error.errors, null, 2)
+      );
       throw new Error("Invalid clinic data: " + error.message);
     }
+    console.error("[CLINIC] Unhandled error in createClinic:", error);
     throw error;
   }
 }
@@ -176,6 +414,7 @@ export async function getClinicsByGroup(
  * @param data - Data to update
  * @param adminId - ID of the admin making the update
  * @param clinicAdminService - Service for clinic admin operations
+ * @param app - Firebase app instance
  * @returns The updated clinic
  */
 export async function updateClinic(
@@ -183,37 +422,231 @@ export async function updateClinic(
   clinicId: string,
   data: Partial<Clinic>,
   adminId: string,
-  clinicAdminService: any
+  clinicAdminService: any,
+  app: FirebaseApp
 ): Promise<Clinic> {
+  console.log("[CLINIC] Starting clinic update", { clinicId, adminId });
+
   const clinic = await getClinic(db, clinicId);
   if (!clinic) {
+    console.error("[CLINIC] Clinic not found", { clinicId });
     throw new Error("Clinic not found");
   }
 
   // Proveravamo da li admin ima prava da ažurira kliniku
-  const admin = await clinicAdminService.getClinicAdmin(adminId);
-  if (!admin) {
-    throw new Error("Admin not found");
+  try {
+    console.log("[CLINIC] Checking admin permissions");
+    const admin = await clinicAdminService.getClinicAdmin(adminId);
+    if (!admin) {
+      console.error("[CLINIC] Admin not found", { adminId });
+      throw new Error("Admin not found");
+    }
+
+    // Check if admin is either:
+    // 1. The owner of the clinic group, OR
+    // 2. Has this clinic in their managed clinics list, OR
+    // 3. Is listed in the clinic's admins array
+    const hasPermission =
+      (admin.isGroupOwner && admin.clinicGroupId === clinic.clinicGroupId) ||
+      (admin.clinicsManaged.includes(clinicId) &&
+        clinic.admins &&
+        clinic.admins.includes(adminId));
+
+    if (!hasPermission) {
+      console.error(
+        "[CLINIC] Admin does not have permission to update this clinic",
+        {
+          adminId,
+          clinicId,
+          isGroupOwner: admin.isGroupOwner,
+          clinicsManaged: admin.clinicsManaged,
+          isClinicAdmin: clinic.admins && clinic.admins.includes(adminId),
+        }
+      );
+      throw new Error("Admin does not have permission to update this clinic");
+    }
+    console.log("[CLINIC] Admin permissions verified");
+  } catch (adminError) {
+    console.error("[CLINIC] Error verifying admin permissions:", adminError);
+    throw adminError;
+  }
+
+  // Process photos in the update data
+  let updatedData = { ...data };
+
+  // Handle logo update if provided
+  if (
+    data.logo &&
+    typeof data.logo === "string" &&
+    data.logo.startsWith("data:")
+  ) {
+    console.log("[CLINIC] Processing logo update");
+    try {
+      const logoUrl = await uploadPhoto(
+        data.logo,
+        "clinics",
+        clinicId,
+        "logo",
+        app
+      );
+      console.log("[CLINIC] Logo update processed", { logoUrl });
+
+      if (logoUrl !== null) {
+        updatedData.logo = logoUrl;
+      }
+    } catch (logoError) {
+      console.error("[CLINIC] Error processing logo update:", logoError);
+      // Continue with update even if logo upload fails
+    }
+  }
+
+  // Handle regular photos update if provided
+  if (data.photos && data.photos.length > 0) {
+    console.log("[CLINIC] Processing regular photos update");
+    try {
+      // Filter out only data URLs that need to be uploaded
+      const dataUrlPhotos = data.photos.filter(
+        (photo) => typeof photo === "string" && photo.startsWith("data:")
+      );
+      const existingPhotos = data.photos.filter(
+        (photo) => typeof photo === "string" && !photo.startsWith("data:")
+      );
+
+      if (dataUrlPhotos.length > 0) {
+        const uploadedPhotos = await uploadMultiplePhotos(
+          dataUrlPhotos,
+          "clinics",
+          clinicId,
+          "photo",
+          app
+        );
+        console.log("[CLINIC] Regular photos update processed", {
+          count: uploadedPhotos.length,
+        });
+
+        // Combine existing photos with newly uploaded ones
+        updatedData.photos = [...existingPhotos, ...uploadedPhotos];
+      }
+    } catch (photosError) {
+      console.error(
+        "[CLINIC] Error processing regular photos update:",
+        photosError
+      );
+      // Continue with update even if photos upload fails
+      updatedData.photos = data.photos.filter(
+        (photo) => typeof photo === "string" && !photo.startsWith("data:")
+      );
+    }
   }
 
-  if (!admin.isGroupOwner && !admin.clinicsManaged.includes(clinicId)) {
-    throw new Error("Admin does not have permission to update this clinic");
+  // Handle featured photos update if provided
+  if (data.featuredPhotos && data.featuredPhotos.length > 0) {
+    console.log("[CLINIC] Processing featured photos update");
+    try {
+      // Filter out only data URLs that need to be uploaded
+      const dataUrlPhotos = data.featuredPhotos.filter(
+        (photo) => typeof photo === "string" && photo.startsWith("data:")
+      );
+      const existingPhotos = data.featuredPhotos.filter(
+        (photo) => typeof photo === "string" && !photo.startsWith("data:")
+      );
+
+      if (dataUrlPhotos.length > 0) {
+        const uploadedPhotos = await uploadMultiplePhotos(
+          dataUrlPhotos,
+          "clinics",
+          clinicId,
+          "featured",
+          app
+        );
+        console.log("[CLINIC] Featured photos update processed", {
+          count: uploadedPhotos.length,
+        });
+
+        // Combine existing photos with newly uploaded ones
+        updatedData.featuredPhotos = [...existingPhotos, ...uploadedPhotos];
+      }
+    } catch (featuredError) {
+      console.error(
+        "[CLINIC] Error processing featured photos update:",
+        featuredError
+      );
+      // Continue with update even if featured photos upload fails
+      updatedData.featuredPhotos = data.featuredPhotos.filter(
+        (photo) => typeof photo === "string" && !photo.startsWith("data:")
+      );
+    }
   }
 
-  // Ažuriramo podatke
-  const updatedData = {
-    ...data,
+  // Handle photos with tags update if provided
+  if (data.photosWithTags && data.photosWithTags.length > 0) {
+    console.log("[CLINIC] Processing photos with tags update");
+    try {
+      const updatedPhotosWithTags = [];
+
+      // Process each photo with tag
+      for (const photoWithTag of data.photosWithTags) {
+        if (photoWithTag.url && photoWithTag.url.startsWith("data:")) {
+          // Upload new photo
+          const uploadedUrl = await uploadPhoto(
+            photoWithTag.url,
+            "clinics",
+            clinicId,
+            `tagged-${photoWithTag.tag}`,
+            app
+          );
+
+          if (uploadedUrl) {
+            updatedPhotosWithTags.push({
+              url: uploadedUrl,
+              tag: photoWithTag.tag,
+            });
+          }
+        } else {
+          // Keep existing photo
+          updatedPhotosWithTags.push(photoWithTag);
+        }
+      }
+
+      updatedData.photosWithTags = updatedPhotosWithTags;
+      console.log("[CLINIC] Photos with tags update processed", {
+        count: updatedPhotosWithTags.length,
+      });
+    } catch (tagsError) {
+      console.error(
+        "[CLINIC] Error processing photos with tags update:",
+        tagsError
+      );
+      // Continue with update even if photos with tags upload fails
+      updatedData.photosWithTags = data.photosWithTags.filter(
+        (photo) => !photo.url.startsWith("data:")
+      );
+    }
+  }
+
+  // Add timestamp
+  updatedData = {
+    ...updatedData,
     updatedAt: Timestamp.now(),
   };
 
-  await updateDoc(doc(db, CLINICS_COLLECTION, clinicId), updatedData);
+  console.log("[CLINIC] Updating clinic in Firestore");
+  try {
+    await updateDoc(doc(db, CLINICS_COLLECTION, clinicId), updatedData);
+    console.log("[CLINIC] Clinic updated successfully");
+  } catch (updateError) {
+    console.error("[CLINIC] Error updating clinic in Firestore:", updateError);
+    throw updateError;
+  }
 
-  // Vraćamo ažurirane podatke
+  // Return updated data
   const updatedClinic = await getClinic(db, clinicId);
   if (!updatedClinic) {
+    console.error("[CLINIC] Failed to retrieve updated clinic");
     throw new Error("Failed to retrieve updated clinic");
   }
 
+  console.log("[CLINIC] Clinic update completed successfully");
   return updatedClinic;
 }
 
@@ -241,7 +674,17 @@ export async function deactivateClinic(
     throw new Error("Admin not found");
   }
 
-  if (!admin.isGroupOwner && !admin.clinicsManaged.includes(clinicId)) {
+  // Check if admin is either:
+  // 1. The owner of the clinic group, OR
+  // 2. Has this clinic in their managed clinics list, OR
+  // 3. Is listed in the clinic's admins array
+  const hasPermission =
+    (admin.isGroupOwner && admin.clinicGroupId === clinic.clinicGroupId) ||
+    (admin.clinicsManaged.includes(clinicId) &&
+      clinic.admins &&
+      clinic.admins.includes(adminId));
+
+  if (!hasPermission) {
     throw new Error("Admin does not have permission to deactivate this clinic");
   }