@blackcode_sa/metaestetics-api 1.12.61 → 1.12.62

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

@@ -1,949 +1,949 @@
-import {
-  collection,
-  doc,
-  getDoc,
-  getDocs,
-  query,
-  where,
-  updateDoc,
-  setDoc,
-  deleteDoc,
-  Timestamp,
-  Firestore,
-  QueryConstraint,
-  addDoc,
-  writeBatch,
-  limit,
-  startAfter,
-} from "firebase/firestore";
-import {
-  Clinic,
-  CreateClinicData,
-  CLINICS_COLLECTION,
-  ClinicTag,
-  ClinicGroup,
-  ClinicBranchSetupData,
-  ClinicLocation,
-} from "../../../types/clinic";
-import {
-  geohashForLocation,
-  distanceBetween,
-  geohashQueryBounds,
-} from "geofire-common";
-import {
-  clinicSchema,
-  createClinicSchema,
-} from "../../../validations/clinic.schema";
-import { z } from "zod";
-import { FirebaseApp } from "firebase/app";
-import {
-  uploadPhoto,
-  uploadMultiplePhotos,
-  processEntityPhotos,
-} from "./photos.utils";
-
-/**
- * Creates a new clinic
- * @param db - Firestore database instance
- * @param data - Clinic data
- * @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(
-  db: Firestore,
-  data: CreateClinicData,
-  creatorAdminId: string,
-  clinicGroupService: 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
-  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) {
-      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
-  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) {
-    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 cover photo upload
-  let processedCoverPhoto: string | null = null;
-  if (validatedData.coverPhoto) {
-    console.log("[CLINIC] Processing cover photo");
-    try {
-      processedCoverPhoto = await uploadPhoto(
-        validatedData.coverPhoto,
-        "clinics",
-        clinicId,
-        "cover",
-        app
-      );
-      console.log("[CLINIC] Cover photo processed", {
-        coverPhoto: processedCoverPhoto,
-      });
-    } catch (coverPhotoError) {
-      console.error("[CLINIC] Error processing cover photo:", coverPhotoError);
-      // Continue with clinic creation even if cover photo upload fails
-      processedCoverPhoto = validatedData.coverPhoto.startsWith("data:")
-        ? null
-        : validatedData.coverPhoto;
-    }
-  }
-
-  // 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: clinicId,
-    description: validatedData.description || "",
-    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 || "",
-    },
-    contactInfo: {
-      email: validatedData.contactInfo.email || "",
-      phoneNumber: validatedData.contactInfo.phoneNumber || "",
-      alternativePhoneNumber:
-        validatedData.contactInfo.alternativePhoneNumber || "",
-      website: validatedData.contactInfo.website || "",
-    },
-    logo: logoUrl || "",
-    tags: validatedData.tags || [],
-    featuredPhotos: processedFeaturedPhotos || [],
-    coverPhoto: processedCoverPhoto,
-    photosWithTags: processedPhotosWithTags,
-    doctors: [],
-    doctorsInfo: [],
-    procedures: [],
-    proceduresInfo: [],
-    reviewInfo: {
-      totalReviews: 0,
-      averageRating: 0,
-      cleanliness: 0,
-      facilities: 0,
-      staffFriendliness: 0,
-      waitingTime: 0,
-      accessibility: 0,
-      recommendationPercentage: 0,
-    },
-    admins: [creatorAdminId],
-    createdAt: now,
-    updatedAt: now,
-    isActive: true,
-    isVerified: false,
-  };
-
-  try {
-    // Validiramo kompletan objekat
-    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
-    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
-    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
-    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;
-  }
-}
-
-/**
- * Gets a clinic by ID
- * @param db - Firestore database instance
- * @param clinicId - ID of the clinic to get
- * @returns The clinic or null if not found
- */
-export async function getClinic(
-  db: Firestore,
-  clinicId: string
-): Promise<Clinic | null> {
-  const docRef = doc(db, CLINICS_COLLECTION, clinicId);
-  const docSnap = await getDoc(docRef);
-
-  if (docSnap.exists()) {
-    return docSnap.data() as Clinic;
-  }
-
-  return null;
-}
-
-/**
- * Gets all clinics in a group
- * @param db - Firestore database instance
- * @param groupId - ID of the clinic group
- * @returns Array of clinics in the group
- */
-export async function getClinicsByGroup(
-  db: Firestore,
-  groupId: string
-): Promise<Clinic[]> {
-  const q = query(
-    collection(db, CLINICS_COLLECTION),
-    where("clinicGroupId", "==", groupId),
-    where("isActive", "==", true)
-  );
-
-  const querySnapshot = await getDocs(q);
-  return querySnapshot.docs.map((doc) => doc.data() as Clinic);
-}
-
-/**
- * Updates a clinic
- * @param db - Firestore database instance
- * @param clinicId - ID of the clinic to update
- * @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(
-  db: Firestore,
-  clinicId: string,
-  data: Partial<Clinic>,
-  adminId: string,
-  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
-  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 that this clinic belongs to, OR
-    // 2. Has this clinic in their managed clinics list AND 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 cover photo update if provided
-  if (data.coverPhoto) {
-    console.log("[CLINIC] Processing cover photo update");
-    try {
-      // Check if it's a data URL that needs to be uploaded
-      if (
-        typeof data.coverPhoto === "string" &&
-        data.coverPhoto.startsWith("data:")
-      ) {
-        const uploadedPhoto = await uploadPhoto(
-          data.coverPhoto,
-          "clinics",
-          clinicId,
-          "cover",
-          app
-        );
-        if (uploadedPhoto) {
-          updatedData.coverPhoto = uploadedPhoto;
-        }
-      } else {
-        // Keep existing photo URL
-        updatedData.coverPhoto = data.coverPhoto;
-      }
-      console.log("[CLINIC] Cover photo update processed");
-    } catch (photoError) {
-      console.error(
-        "[CLINIC] Error processing cover photo update:",
-        photoError
-      );
-      // Keep existing photo if upload fails
-      if (
-        typeof data.coverPhoto === "string" &&
-        !data.coverPhoto.startsWith("data:")
-      ) {
-        updatedData.coverPhoto = data.coverPhoto;
-      }
-    }
-  }
-
-  // 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];
-      } else {
-        // If no new photos to upload, just use the existing ones
-        updatedData.featuredPhotos = existingPhotos;
-      }
-    } 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:")
-      );
-    }
-  }
-
-  // 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(),
-  };
-
-  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;
-  }
-
-  // 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;
-}
-
-/**
- * Deactivates a clinic
- * @param db - Firestore database instance
- * @param clinicId - ID of the clinic to deactivate
- * @param adminId - ID of the admin making the deactivation
- * @param clinicAdminService - Service for clinic admin operations
- */
-export async function deactivateClinic(
-  db: Firestore,
-  clinicId: string,
-  adminId: string,
-  clinicAdminService: any
-): Promise<void> {
-  const clinic = await getClinic(db, clinicId);
-  if (!clinic) {
-    throw new Error("Clinic not found");
-  }
-
-  // Proveravamo da li admin ima prava da deaktivira kliniku
-  const admin = await clinicAdminService.getClinicAdmin(adminId);
-  if (!admin) {
-    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) {
-    throw new Error("Admin does not have permission to deactivate this clinic");
-  }
-
-  await updateDoc(doc(db, CLINICS_COLLECTION, clinicId), {
-    isActive: false,
-    updatedAt: Timestamp.now(),
-  });
-}
-
-/**
- * Gets clinics managed by an admin
- * @param db - Firestore database instance
- * @param adminId - ID of the admin
- * @param options - Options for filtering clinics
- * @param clinicAdminService - Service for clinic admin operations
- * @param clinicGroupService - Service for clinic group operations
- * @returns Array of clinics managed by the admin
- */
-export async function getClinicsByAdmin(
-  db: Firestore,
-  adminId: string,
-  options: {
-    isActive?: boolean;
-    includeGroupClinics?: boolean;
-  } = {},
-  clinicAdminService: any,
-  clinicGroupService: any
-): Promise<Clinic[]> {
-  const admin = await clinicAdminService.getClinicAdmin(adminId);
-  if (!admin) {
-    throw new Error("Admin not found");
-  }
-
-  let clinicIds: string[] = [...admin.clinicsManaged];
-
-  // Ako je admin vlasnik grupe i tražimo sve klinike grupe
-  if (admin.isGroupOwner && options.includeGroupClinics) {
-    const group = await clinicGroupService.getClinicGroup(admin.clinicGroupId);
-    if (group) {
-      clinicIds = [...new Set([...clinicIds, ...group.clinics])];
-    }
-  }
-
-  if (clinicIds.length === 0) {
-    return [];
-  }
-
-  const constraints: QueryConstraint[] = [where("id", "in", clinicIds)];
-
-  if (options.isActive !== undefined) {
-    constraints.push(where("isActive", "==", options.isActive));
-  }
-
-  const q = query(collection(db, CLINICS_COLLECTION), ...constraints);
-  const querySnapshot = await getDocs(q);
-
-  return querySnapshot.docs.map((doc) => doc.data() as Clinic);
-}
-
-/**
- * Gets active clinics managed by an admin
- * @param db - Firestore database instance
- * @param adminId - ID of the admin
- * @param clinicAdminService - Service for clinic admin operations
- * @param clinicGroupService - Service for clinic group operations
- * @returns Array of active clinics managed by the admin
- */
-export async function getActiveClinicsByAdmin(
-  db: Firestore,
-  adminId: string,
-  clinicAdminService: any,
-  clinicGroupService: any
-): Promise<Clinic[]> {
-  return getClinicsByAdmin(
-    db,
-    adminId,
-    { isActive: true },
-    clinicAdminService,
-    clinicGroupService
-  );
-}
-
-/**
- * Retrieves a clinic by its ID
- *
- * @param db - Firestore database instance
- * @param clinicId - ID of the clinic to retrieve
- * @returns The clinic if found, null otherwise
- */
-export async function getClinicById(
-  db: Firestore,
-  clinicId: string
-): Promise<Clinic | null> {
-  try {
-    const clinicRef = doc(db, CLINICS_COLLECTION, clinicId);
-    const clinicSnapshot = await getDoc(clinicRef);
-
-    if (!clinicSnapshot.exists()) {
-      return null;
-    }
-
-    const clinicData = clinicSnapshot.data() as Clinic;
-    return {
-      ...clinicData,
-      id: clinicSnapshot.id,
-    };
-  } catch (error) {
-    console.error("[CLINIC_UTILS] Error getting clinic by ID:", error);
-    throw error;
-  }
-}
-
-/**
- * Retrieves all clinics with optional pagination
- *
- * @param db - Firestore database instance
- * @param pagination - Optional number of clinics per page (0 or undefined returns all)
- * @param lastDoc - Optional last document for pagination (if continuing from a previous page)
- * @returns Array of clinics and the last document for pagination
- */
-export async function getAllClinics(
-  db: Firestore,
-  pagination?: number,
-  lastDoc?: any
-): Promise<{ clinics: Clinic[]; lastDoc: any }> {
-  try {
-    const clinicsCollection = collection(db, CLINICS_COLLECTION);
-    let clinicsQuery = query(clinicsCollection);
-
-    // If pagination is specified and greater than 0, limit the query
-    if (pagination && pagination > 0) {
-      if (lastDoc) {
-        clinicsQuery = query(
-          clinicsCollection,
-          startAfter(lastDoc),
-          limit(pagination)
-        );
-      } else {
-        clinicsQuery = query(clinicsCollection, limit(pagination));
-      }
-    }
-
-    const clinicsSnapshot = await getDocs(clinicsQuery);
-    const lastVisible = clinicsSnapshot.docs[clinicsSnapshot.docs.length - 1];
-
-    const clinics = clinicsSnapshot.docs.map((doc) => {
-      const data = doc.data() as Clinic;
-      return {
-        ...data,
-        id: doc.id,
-      };
-    });
-
-    return {
-      clinics,
-      lastDoc: lastVisible,
-    };
-  } catch (error) {
-    console.error("[CLINIC_UTILS] Error getting all clinics:", error);
-    throw error;
-  }
-}
-
-/**
- * Retrieves all clinics within a specified range from a location with optional pagination
- *
- * @param db - Firestore database instance
- * @param center - The center location coordinates {latitude, longitude}
- * @param rangeInKm - The range in kilometers to search within
- * @param pagination - Optional number of clinics per page (0 or undefined returns all)
- * @param lastDoc - Optional last document for pagination (if continuing from a previous page)
- * @returns Array of clinics with distance information and the last document for pagination
- */
-export async function getAllClinicsInRange(
-  db: Firestore,
-  center: { latitude: number; longitude: number },
-  rangeInKm: number,
-  pagination?: number,
-  lastDoc?: any
-): Promise<{ clinics: (Clinic & { distance: number })[]; lastDoc: any }> {
-  const bounds = geohashQueryBounds(
-    [center.latitude, center.longitude],
-    rangeInKm * 1000
-  );
-
-  const matchingClinics: (Clinic & { distance: number })[] = [];
-  let lastDocSnapshot = null;
-
-  for (const b of bounds) {
-    const constraints: QueryConstraint[] = [
-      where("location.geohash", ">=", b[0]),
-      where("location.geohash", "<=", b[1]),
-      where("isActive", "==", true),
-    ];
-
-    const q = query(collection(db, CLINICS_COLLECTION), ...constraints);
-    const querySnapshot = await getDocs(q);
-
-    for (const doc of querySnapshot.docs) {
-      const clinic = doc.data() as Clinic;
-      const distance = distanceBetween(
-        [center.latitude, center.longitude],
-        [clinic.location.latitude, clinic.location.longitude]
-      );
-
-      // Convert to kilometers
-      const distanceInKm = distance / 1000;
-
-      if (distanceInKm <= rangeInKm) {
-        matchingClinics.push({
-          ...clinic,
-          distance: distanceInKm,
-        });
-      }
-    }
-  }
-
-  // Sort by distance
-  matchingClinics.sort((a, b) => a.distance - b.distance);
-
-  if (pagination && pagination > 0) {
-    // Paginate results
-    let result = matchingClinics;
-    if (lastDoc && matchingClinics.length > 0) {
-      const lastIndex = matchingClinics.findIndex(
-        (clinic) => clinic.id === lastDoc.id
-      );
-      if (lastIndex !== -1) {
-        result = matchingClinics.slice(lastIndex + 1);
-      }
-    }
-
-    const paginatedClinics = result.slice(0, pagination);
-    const newLastDoc =
-      paginatedClinics.length > 0
-        ? paginatedClinics[paginatedClinics.length - 1]
-        : null;
-
-    return {
-      clinics: paginatedClinics,
-      lastDoc: newLastDoc,
-    };
-  }
-
-  return {
-    clinics: matchingClinics,
-    lastDoc: null,
-  };
-}
+import {
+  collection,
+  doc,
+  getDoc,
+  getDocs,
+  query,
+  where,
+  updateDoc,
+  setDoc,
+  deleteDoc,
+  Timestamp,
+  Firestore,
+  QueryConstraint,
+  addDoc,
+  writeBatch,
+  limit,
+  startAfter,
+} from "firebase/firestore";
+import {
+  Clinic,
+  CreateClinicData,
+  CLINICS_COLLECTION,
+  ClinicTag,
+  ClinicGroup,
+  ClinicBranchSetupData,
+  ClinicLocation,
+} from "../../../types/clinic";
+import {
+  geohashForLocation,
+  distanceBetween,
+  geohashQueryBounds,
+} from "geofire-common";
+import {
+  clinicSchema,
+  createClinicSchema,
+} from "../../../validations/clinic.schema";
+import { z } from "zod";
+import { FirebaseApp } from "firebase/app";
+import {
+  uploadPhoto,
+  uploadMultiplePhotos,
+  processEntityPhotos,
+} from "./photos.utils";
+
+/**
+ * Creates a new clinic
+ * @param db - Firestore database instance
+ * @param data - Clinic data
+ * @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(
+  db: Firestore,
+  data: CreateClinicData,
+  creatorAdminId: string,
+  clinicGroupService: 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
+  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) {
+      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
+  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) {
+    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 cover photo upload
+  let processedCoverPhoto: string | null = null;
+  if (validatedData.coverPhoto) {
+    console.log("[CLINIC] Processing cover photo");
+    try {
+      processedCoverPhoto = await uploadPhoto(
+        validatedData.coverPhoto,
+        "clinics",
+        clinicId,
+        "cover",
+        app
+      );
+      console.log("[CLINIC] Cover photo processed", {
+        coverPhoto: processedCoverPhoto,
+      });
+    } catch (coverPhotoError) {
+      console.error("[CLINIC] Error processing cover photo:", coverPhotoError);
+      // Continue with clinic creation even if cover photo upload fails
+      processedCoverPhoto = validatedData.coverPhoto.startsWith("data:")
+        ? null
+        : validatedData.coverPhoto;
+    }
+  }
+
+  // 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: clinicId,
+    description: validatedData.description || "",
+    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 || "",
+    },
+    contactInfo: {
+      email: validatedData.contactInfo.email || "",
+      phoneNumber: validatedData.contactInfo.phoneNumber || "",
+      alternativePhoneNumber:
+        validatedData.contactInfo.alternativePhoneNumber || "",
+      website: validatedData.contactInfo.website || "",
+    },
+    logo: logoUrl || "",
+    tags: validatedData.tags || [],
+    featuredPhotos: processedFeaturedPhotos || [],
+    coverPhoto: processedCoverPhoto,
+    photosWithTags: processedPhotosWithTags,
+    doctors: [],
+    doctorsInfo: [],
+    procedures: [],
+    proceduresInfo: [],
+    reviewInfo: {
+      totalReviews: 0,
+      averageRating: 0,
+      cleanliness: 0,
+      facilities: 0,
+      staffFriendliness: 0,
+      waitingTime: 0,
+      accessibility: 0,
+      recommendationPercentage: 0,
+    },
+    admins: [creatorAdminId],
+    createdAt: now,
+    updatedAt: now,
+    isActive: true,
+    isVerified: false,
+  };
+
+  try {
+    // Validiramo kompletan objekat
+    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
+    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
+    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
+    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;
+  }
+}
+
+/**
+ * Gets a clinic by ID
+ * @param db - Firestore database instance
+ * @param clinicId - ID of the clinic to get
+ * @returns The clinic or null if not found
+ */
+export async function getClinic(
+  db: Firestore,
+  clinicId: string
+): Promise<Clinic | null> {
+  const docRef = doc(db, CLINICS_COLLECTION, clinicId);
+  const docSnap = await getDoc(docRef);
+
+  if (docSnap.exists()) {
+    return docSnap.data() as Clinic;
+  }
+
+  return null;
+}
+
+/**
+ * Gets all clinics in a group
+ * @param db - Firestore database instance
+ * @param groupId - ID of the clinic group
+ * @returns Array of clinics in the group
+ */
+export async function getClinicsByGroup(
+  db: Firestore,
+  groupId: string
+): Promise<Clinic[]> {
+  const q = query(
+    collection(db, CLINICS_COLLECTION),
+    where("clinicGroupId", "==", groupId),
+    where("isActive", "==", true)
+  );
+
+  const querySnapshot = await getDocs(q);
+  return querySnapshot.docs.map((doc) => doc.data() as Clinic);
+}
+
+/**
+ * Updates a clinic
+ * @param db - Firestore database instance
+ * @param clinicId - ID of the clinic to update
+ * @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(
+  db: Firestore,
+  clinicId: string,
+  data: Partial<Clinic>,
+  adminId: string,
+  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
+  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 that this clinic belongs to, OR
+    // 2. Has this clinic in their managed clinics list AND 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 cover photo update if provided
+  if (data.coverPhoto) {
+    console.log("[CLINIC] Processing cover photo update");
+    try {
+      // Check if it's a data URL that needs to be uploaded
+      if (
+        typeof data.coverPhoto === "string" &&
+        data.coverPhoto.startsWith("data:")
+      ) {
+        const uploadedPhoto = await uploadPhoto(
+          data.coverPhoto,
+          "clinics",
+          clinicId,
+          "cover",
+          app
+        );
+        if (uploadedPhoto) {
+          updatedData.coverPhoto = uploadedPhoto;
+        }
+      } else {
+        // Keep existing photo URL
+        updatedData.coverPhoto = data.coverPhoto;
+      }
+      console.log("[CLINIC] Cover photo update processed");
+    } catch (photoError) {
+      console.error(
+        "[CLINIC] Error processing cover photo update:",
+        photoError
+      );
+      // Keep existing photo if upload fails
+      if (
+        typeof data.coverPhoto === "string" &&
+        !data.coverPhoto.startsWith("data:")
+      ) {
+        updatedData.coverPhoto = data.coverPhoto;
+      }
+    }
+  }
+
+  // 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];
+      } else {
+        // If no new photos to upload, just use the existing ones
+        updatedData.featuredPhotos = existingPhotos;
+      }
+    } 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:")
+      );
+    }
+  }
+
+  // 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(),
+  };
+
+  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;
+  }
+
+  // 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;
+}
+
+/**
+ * Deactivates a clinic
+ * @param db - Firestore database instance
+ * @param clinicId - ID of the clinic to deactivate
+ * @param adminId - ID of the admin making the deactivation
+ * @param clinicAdminService - Service for clinic admin operations
+ */
+export async function deactivateClinic(
+  db: Firestore,
+  clinicId: string,
+  adminId: string,
+  clinicAdminService: any
+): Promise<void> {
+  const clinic = await getClinic(db, clinicId);
+  if (!clinic) {
+    throw new Error("Clinic not found");
+  }
+
+  // Proveravamo da li admin ima prava da deaktivira kliniku
+  const admin = await clinicAdminService.getClinicAdmin(adminId);
+  if (!admin) {
+    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) {
+    throw new Error("Admin does not have permission to deactivate this clinic");
+  }
+
+  await updateDoc(doc(db, CLINICS_COLLECTION, clinicId), {
+    isActive: false,
+    updatedAt: Timestamp.now(),
+  });
+}
+
+/**
+ * Gets clinics managed by an admin
+ * @param db - Firestore database instance
+ * @param adminId - ID of the admin
+ * @param options - Options for filtering clinics
+ * @param clinicAdminService - Service for clinic admin operations
+ * @param clinicGroupService - Service for clinic group operations
+ * @returns Array of clinics managed by the admin
+ */
+export async function getClinicsByAdmin(
+  db: Firestore,
+  adminId: string,
+  options: {
+    isActive?: boolean;
+    includeGroupClinics?: boolean;
+  } = {},
+  clinicAdminService: any,
+  clinicGroupService: any
+): Promise<Clinic[]> {
+  const admin = await clinicAdminService.getClinicAdmin(adminId);
+  if (!admin) {
+    throw new Error("Admin not found");
+  }
+
+  let clinicIds: string[] = [...admin.clinicsManaged];
+
+  // Ako je admin vlasnik grupe i tražimo sve klinike grupe
+  if (admin.isGroupOwner && options.includeGroupClinics) {
+    const group = await clinicGroupService.getClinicGroup(admin.clinicGroupId);
+    if (group) {
+      clinicIds = [...new Set([...clinicIds, ...group.clinics])];
+    }
+  }
+
+  if (clinicIds.length === 0) {
+    return [];
+  }
+
+  const constraints: QueryConstraint[] = [where("id", "in", clinicIds)];
+
+  if (options.isActive !== undefined) {
+    constraints.push(where("isActive", "==", options.isActive));
+  }
+
+  const q = query(collection(db, CLINICS_COLLECTION), ...constraints);
+  const querySnapshot = await getDocs(q);
+
+  return querySnapshot.docs.map((doc) => doc.data() as Clinic);
+}
+
+/**
+ * Gets active clinics managed by an admin
+ * @param db - Firestore database instance
+ * @param adminId - ID of the admin
+ * @param clinicAdminService - Service for clinic admin operations
+ * @param clinicGroupService - Service for clinic group operations
+ * @returns Array of active clinics managed by the admin
+ */
+export async function getActiveClinicsByAdmin(
+  db: Firestore,
+  adminId: string,
+  clinicAdminService: any,
+  clinicGroupService: any
+): Promise<Clinic[]> {
+  return getClinicsByAdmin(
+    db,
+    adminId,
+    { isActive: true },
+    clinicAdminService,
+    clinicGroupService
+  );
+}
+
+/**
+ * Retrieves a clinic by its ID
+ *
+ * @param db - Firestore database instance
+ * @param clinicId - ID of the clinic to retrieve
+ * @returns The clinic if found, null otherwise
+ */
+export async function getClinicById(
+  db: Firestore,
+  clinicId: string
+): Promise<Clinic | null> {
+  try {
+    const clinicRef = doc(db, CLINICS_COLLECTION, clinicId);
+    const clinicSnapshot = await getDoc(clinicRef);
+
+    if (!clinicSnapshot.exists()) {
+      return null;
+    }
+
+    const clinicData = clinicSnapshot.data() as Clinic;
+    return {
+      ...clinicData,
+      id: clinicSnapshot.id,
+    };
+  } catch (error) {
+    console.error("[CLINIC_UTILS] Error getting clinic by ID:", error);
+    throw error;
+  }
+}
+
+/**
+ * Retrieves all clinics with optional pagination
+ *
+ * @param db - Firestore database instance
+ * @param pagination - Optional number of clinics per page (0 or undefined returns all)
+ * @param lastDoc - Optional last document for pagination (if continuing from a previous page)
+ * @returns Array of clinics and the last document for pagination
+ */
+export async function getAllClinics(
+  db: Firestore,
+  pagination?: number,
+  lastDoc?: any
+): Promise<{ clinics: Clinic[]; lastDoc: any }> {
+  try {
+    const clinicsCollection = collection(db, CLINICS_COLLECTION);
+    let clinicsQuery = query(clinicsCollection);
+
+    // If pagination is specified and greater than 0, limit the query
+    if (pagination && pagination > 0) {
+      if (lastDoc) {
+        clinicsQuery = query(
+          clinicsCollection,
+          startAfter(lastDoc),
+          limit(pagination)
+        );
+      } else {
+        clinicsQuery = query(clinicsCollection, limit(pagination));
+      }
+    }
+
+    const clinicsSnapshot = await getDocs(clinicsQuery);
+    const lastVisible = clinicsSnapshot.docs[clinicsSnapshot.docs.length - 1];
+
+    const clinics = clinicsSnapshot.docs.map((doc) => {
+      const data = doc.data() as Clinic;
+      return {
+        ...data,
+        id: doc.id,
+      };
+    });
+
+    return {
+      clinics,
+      lastDoc: lastVisible,
+    };
+  } catch (error) {
+    console.error("[CLINIC_UTILS] Error getting all clinics:", error);
+    throw error;
+  }
+}
+
+/**
+ * Retrieves all clinics within a specified range from a location with optional pagination
+ *
+ * @param db - Firestore database instance
+ * @param center - The center location coordinates {latitude, longitude}
+ * @param rangeInKm - The range in kilometers to search within
+ * @param pagination - Optional number of clinics per page (0 or undefined returns all)
+ * @param lastDoc - Optional last document for pagination (if continuing from a previous page)
+ * @returns Array of clinics with distance information and the last document for pagination
+ */
+export async function getAllClinicsInRange(
+  db: Firestore,
+  center: { latitude: number; longitude: number },
+  rangeInKm: number,
+  pagination?: number,
+  lastDoc?: any
+): Promise<{ clinics: (Clinic & { distance: number })[]; lastDoc: any }> {
+  const bounds = geohashQueryBounds(
+    [center.latitude, center.longitude],
+    rangeInKm * 1000
+  );
+
+  const matchingClinics: (Clinic & { distance: number })[] = [];
+  let lastDocSnapshot = null;
+
+  for (const b of bounds) {
+    const constraints: QueryConstraint[] = [
+      where("location.geohash", ">=", b[0]),
+      where("location.geohash", "<=", b[1]),
+      where("isActive", "==", true),
+    ];
+
+    const q = query(collection(db, CLINICS_COLLECTION), ...constraints);
+    const querySnapshot = await getDocs(q);
+
+    for (const doc of querySnapshot.docs) {
+      const clinic = doc.data() as Clinic;
+      const distance = distanceBetween(
+        [center.latitude, center.longitude],
+        [clinic.location.latitude, clinic.location.longitude]
+      );
+
+      // Convert to kilometers
+      const distanceInKm = distance / 1000;
+
+      if (distanceInKm <= rangeInKm) {
+        matchingClinics.push({
+          ...clinic,
+          distance: distanceInKm,
+        });
+      }
+    }
+  }
+
+  // Sort by distance
+  matchingClinics.sort((a, b) => a.distance - b.distance);
+
+  if (pagination && pagination > 0) {
+    // Paginate results
+    let result = matchingClinics;
+    if (lastDoc && matchingClinics.length > 0) {
+      const lastIndex = matchingClinics.findIndex(
+        (clinic) => clinic.id === lastDoc.id
+      );
+      if (lastIndex !== -1) {
+        result = matchingClinics.slice(lastIndex + 1);
+      }
+    }
+
+    const paginatedClinics = result.slice(0, pagination);
+    const newLastDoc =
+      paginatedClinics.length > 0
+        ? paginatedClinics[paginatedClinics.length - 1]
+        : null;
+
+    return {
+      clinics: paginatedClinics,
+      lastDoc: newLastDoc,
+    };
+  }
+
+  return {
+    clinics: matchingClinics,
+    lastDoc: null,
+  };
+}