@blackcode_sa/metaestetics-api 1.13.4 → 1.13.5

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

@@ -1,551 +1,551 @@
-import {
-  collection,
-  doc,
-  getDoc,
-  getDocs,
-  query,
-  where,
-  updateDoc,
-  setDoc,
-  deleteDoc,
-  Timestamp,
-  Firestore,
-  serverTimestamp,
-  FieldValue,
-} from "firebase/firestore";
-import {
-  ClinicAdmin,
-  CreateClinicAdminData,
-  UpdateClinicAdminData,
-  CLINIC_ADMINS_COLLECTION,
-  CreateDefaultClinicGroupData,
-} from "../../../types/clinic";
-import {
-  clinicAdminSchema,
-  createClinicAdminSchema,
-} from "../../../validations/clinic.schema";
-import { z } from "zod";
-
-/**
- * Creates a new clinic admin
- * @param db - Firestore database instance
- * @param data - Admin data
- * @param clinicGroupService - Service for clinic group operations
- * @returns The created clinic admin
- */
-export async function createClinicAdmin(
-  db: Firestore,
-  data: CreateClinicAdminData,
-  clinicGroupService: any
-): Promise<ClinicAdmin> {
-  console.log("[CLINIC_ADMIN] Starting clinic admin creation", {
-    userRef: data.userRef,
-  });
-  console.log("[CLINIC_ADMIN] Input data:", JSON.stringify(data, null, 2));
-
-  // Validacija podataka
-  try {
-    const validatedData = createClinicAdminSchema.parse(data);
-    console.log("[CLINIC_ADMIN] Data validation passed");
-  } catch (validationError) {
-    console.error("[CLINIC_ADMIN] Data validation failed:", validationError);
-    throw validationError;
-  }
-
-  const validatedData = createClinicAdminSchema.parse(data);
-
-  // Proveravamo da li korisnik već ima admin profil
-  console.log("[CLINIC_ADMIN] Checking if user already has an admin profile", {
-    userRef: validatedData.userRef,
-  });
-  try {
-    const existingAdmin = await getClinicAdminByUserRef(
-      db,
-      validatedData.userRef
-    );
-    if (existingAdmin) {
-      console.error("[CLINIC_ADMIN] User already has an admin profile", {
-        adminId: existingAdmin.id,
-      });
-      throw new Error("User already has an admin profile");
-    }
-    console.log("[CLINIC_ADMIN] User does not have an existing admin profile");
-  } catch (error: any) {
-    if (error.message === "User already has an admin profile") {
-      throw error;
-    }
-    console.error("[CLINIC_ADMIN] Error checking for existing admin:", error);
-    throw error;
-  }
-
-  // Ako je owner, kreiramo default grupu ako nije prosleđen groupId
-  let clinicGroupId = validatedData.clinicGroupId;
-  console.log("[CLINIC_ADMIN] Checking clinic group situation", {
-    isGroupOwner: validatedData.isGroupOwner,
-    hasGroupId: !!clinicGroupId,
-  });
-
-  // For owners creating a new group, we'll set the group ID later
-  if (validatedData.isGroupOwner && !clinicGroupId) {
-    console.log("[CLINIC_ADMIN] Owner will be assigned to group later");
-    // Skip creating default group here - will be done in auth service
-  }
-  // Ako nije owner a nemamo groupId, to je greška
-  else if (!validatedData.isGroupOwner && !clinicGroupId) {
-    console.error("[CLINIC_ADMIN] Missing clinic group ID for non-owner admin");
-    throw new Error("Clinic group ID is required for non-owner admins");
-  }
-  // Ako nije owner a imamo groupId, proverimo da li grupa postoji
-  else if (!validatedData.isGroupOwner && clinicGroupId) {
-    console.log("[CLINIC_ADMIN] Checking if specified clinic group exists", {
-      groupId: clinicGroupId,
-    });
-    try {
-      const groupExists = await checkClinicGroupExists(
-        db,
-        clinicGroupId,
-        clinicGroupService
-      );
-      if (!groupExists) {
-        console.error("[CLINIC_ADMIN] Specified clinic group does not exist", {
-          groupId: clinicGroupId,
-        });
-        throw new Error("Specified clinic group does not exist");
-      }
-      console.log("[CLINIC_ADMIN] Specified clinic group exists");
-    } catch (groupCheckError) {
-      console.error(
-        "[CLINIC_ADMIN] Error checking if clinic group exists:",
-        groupCheckError
-      );
-      throw groupCheckError;
-    }
-  }
-
-  console.log("[CLINIC_ADMIN] Preparing admin data object");
-
-  // Allow creating admin without a clinic group for owners
-  const adminData: Omit<ClinicAdmin, "createdAt" | "updatedAt"> & {
-    createdAt: ReturnType<typeof serverTimestamp>;
-    updatedAt: ReturnType<typeof serverTimestamp>;
-  } = {
-    id: doc(collection(db, CLINIC_ADMINS_COLLECTION)).id, // Generate a new ID for the admin document
-    userRef: validatedData.userRef,
-    clinicGroupId: clinicGroupId || "", // Empty string for now if no group ID
-    isGroupOwner: validatedData.isGroupOwner,
-    clinicsManaged: [], // Uvek krećemo od prazne liste
-    clinicsManagedInfo: [], // Empty array for clinic info
-    contactInfo: validatedData.contactInfo,
-    roleTitle: validatedData.roleTitle,
-    isActive: validatedData.isActive,
-    createdAt: serverTimestamp(),
-    updatedAt: serverTimestamp(),
-  };
-
-  // Validacija kompletnog objekta
-  console.log("[CLINIC_ADMIN] Validating complete admin object");
-  try {
-    clinicAdminSchema.parse({
-      ...adminData,
-      createdAt: Timestamp.now(),
-      updatedAt: Timestamp.now(),
-    });
-    console.log("[CLINIC_ADMIN] Admin object validation passed");
-  } catch (schemaError) {
-    console.error(
-      "[CLINIC_ADMIN] Admin object validation failed:",
-      JSON.stringify(schemaError, null, 2)
-    );
-    throw schemaError;
-  }
-
-  // Čuvamo u Firestore
-  console.log("[CLINIC_ADMIN] Saving admin to Firestore", {
-    adminId: adminData.id,
-  });
-  try {
-    await setDoc(doc(db, CLINIC_ADMINS_COLLECTION, adminData.id), adminData);
-    console.log("[CLINIC_ADMIN] Admin saved successfully");
-  } catch (firestoreError) {
-    console.error(
-      "[CLINIC_ADMIN] Error saving admin to Firestore:",
-      firestoreError
-    );
-    throw firestoreError;
-  }
-
-  // Dodajemo admina u grupu
-  if (clinicGroupId) {
-    console.log("[CLINIC_ADMIN] Adding admin to clinic group", {
-      adminId: adminData.id,
-      groupId: clinicGroupId,
-    });
-    try {
-      await clinicGroupService.addAdminToGroup(clinicGroupId, adminData.id);
-      console.log("[CLINIC_ADMIN] Admin added to group successfully");
-    } catch (addToGroupError) {
-      console.error(
-        "[CLINIC_ADMIN] Error adding admin to group:",
-        addToGroupError
-      );
-      throw addToGroupError;
-    }
-  }
-
-  // Vraćamo kreirani objekat
-  console.log("[CLINIC_ADMIN] Retrieving created admin");
-  try {
-    const createdAdmin = await getClinicAdmin(db, adminData.id);
-    if (!createdAdmin) {
-      console.error("[CLINIC_ADMIN] Failed to retrieve created admin");
-      throw new Error("Failed to retrieve created admin");
-    }
-    console.log("[CLINIC_ADMIN] Admin creation completed successfully", {
-      adminId: createdAdmin.id,
-    });
-    return createdAdmin;
-  } catch (retrieveError) {
-    console.error(
-      "[CLINIC_ADMIN] Error retrieving created admin:",
-      retrieveError
-    );
-    throw retrieveError;
-  }
-}
-
-/**
- * Checks if a clinic group exists
- * @param db - Firestore database instance
- * @param groupId - ID of the clinic group
- * @param clinicGroupService - Service for clinic group operations
- * @returns Whether the clinic group exists
- */
-export async function checkClinicGroupExists(
-  db: Firestore,
-  groupId: string,
-  clinicGroupService: any
-): Promise<boolean> {
-  const group = await clinicGroupService.getClinicGroup(groupId);
-  return !!group;
-}
-
-/**
- * Gets a clinic admin by ID
- * @param db - Firestore database instance
- * @param adminId - ID of the admin
- * @returns The clinic admin or null if not found
- */
-export async function getClinicAdmin(
-  db: Firestore,
-  adminId: string
-): Promise<ClinicAdmin | null> {
-  const docRef = doc(db, CLINIC_ADMINS_COLLECTION, adminId);
-  const docSnap = await getDoc(docRef);
-
-  if (docSnap.exists()) {
-    return docSnap.data() as ClinicAdmin;
-  }
-
-  return null;
-}
-
-/**
- * Gets a clinic admin by user reference
- * @param db - Firestore database instance
- * @param userRef - User reference
- * @returns The clinic admin or null if not found
- */
-export async function getClinicAdminByUserRef(
-  db: Firestore,
-  userRef: string
-): Promise<ClinicAdmin | null> {
-  const q = query(
-    collection(db, CLINIC_ADMINS_COLLECTION),
-    where("userRef", "==", userRef)
-  );
-
-  const querySnapshot = await getDocs(q);
-  if (querySnapshot.empty) {
-    return null;
-  }
-
-  return querySnapshot.docs[0].data() as ClinicAdmin;
-}
-
-/**
- * Gets all clinic admins in a group
- * @param db - Firestore database instance
- * @param clinicGroupId - ID of the clinic group
- * @returns Array of clinic admins in the group
- */
-export async function getClinicAdminsByGroup(
-  db: Firestore,
-  clinicGroupId: string
-): Promise<ClinicAdmin[]> {
-  const q = query(
-    collection(db, CLINIC_ADMINS_COLLECTION),
-    where("clinicGroupId", "==", clinicGroupId)
-  );
-
-  const querySnapshot = await getDocs(q);
-  return querySnapshot.docs.map((doc) => doc.data() as ClinicAdmin);
-}
-
-/**
- * Updates a clinic admin
- * @param db - Firestore database instance
- * @param adminId - ID of the admin to update
- * @param data - Data to update
- * @returns The updated clinic admin
- */
-export async function updateClinicAdmin(
-  db: Firestore,
-  adminId: string,
-  data: UpdateClinicAdminData
-): Promise<ClinicAdmin> {
-  const admin = await getClinicAdmin(db, adminId);
-  if (!admin) {
-    throw new Error("Clinic admin not found");
-  }
-
-  // Ažuriramo podatke
-  const updatedData = {
-    ...data,
-    updatedAt: serverTimestamp(),
-  };
-
-  await updateDoc(doc(db, CLINIC_ADMINS_COLLECTION, adminId), updatedData);
-
-  // Vraćamo ažurirane podatke
-  const updatedAdmin = await getClinicAdmin(db, adminId);
-  if (!updatedAdmin) {
-    throw new Error("Failed to retrieve updated admin");
-  }
-
-  return updatedAdmin;
-}
-
-/**
- * Deletes a clinic admin
- * @param db - Firestore database instance
- * @param adminId - ID of the admin to delete
- */
-export async function deleteClinicAdmin(
-  db: Firestore,
-  adminId: string
-): Promise<void> {
-  const admin = await getClinicAdmin(db, adminId);
-  if (!admin) {
-    throw new Error("Clinic admin not found");
-  }
-
-  await deleteDoc(doc(db, CLINIC_ADMINS_COLLECTION, adminId));
-}
-
-/**
- * Adds a clinic to an admin's managed clinics
- * @param db - Firestore database instance
- * @param adminId - ID of the admin
- * @param clinicId - ID of the clinic to add
- * @param requesterId - ID of the admin making the request
- * @param clinicService - Service for clinic operations
- */
-export async function addClinicToManaged(
-  db: Firestore,
-  adminId: string,
-  clinicId: string,
-  requesterId?: string,
-  clinicService?: any
-): Promise<void> {
-  const admin = await getClinicAdmin(db, adminId);
-  if (!admin) {
-    throw new Error("Clinic admin not found");
-  }
-
-  // Ako je prosleđen requester, proveravamo da li ima prava
-  if (requesterId && requesterId !== adminId) {
-    const requester = await getClinicAdmin(db, requesterId);
-    if (!requester) {
-      throw new Error("Requester admin not found");
-    }
-
-    // Samo owner grupe može da dodaje klinike drugim adminima
-    if (
-      !requester.isGroupOwner ||
-      requester.clinicGroupId !== admin.clinicGroupId
-    ) {
-      throw new Error("Only group owner can add clinics to other admins");
-    }
-  }
-
-  // Proveravamo da li klinika već postoji u listi
-  if (admin.clinicsManaged.includes(clinicId)) {
-    return; // Klinika je već u listi
-  }
-
-  // Ažuriramo listu klinika
-  await updateClinicAdmin(db, adminId, {
-    clinicsManaged: [...admin.clinicsManaged, clinicId],
-  });
-
-  // Ako imamo clinicService, dohvatamo info o klinici i dodajemo ga u clinicsManagedInfo
-  if (clinicService) {
-    const clinic = await clinicService.getClinic(clinicId);
-    if (clinic) {
-      await updateClinicAdmin(db, adminId, {
-        clinicsManagedInfo: [
-          ...admin.clinicsManagedInfo,
-          {
-            id: clinic.id,
-            featuredPhoto: clinic.featuredPhotos[0] || "",
-            name: clinic.name,
-            description: clinic.description,
-            location: clinic.location,
-            contactInfo: clinic.contactInfo,
-          },
-        ],
-      });
-    }
-  }
-}
-
-/**
- * Removes a clinic from an admin's managed clinics
- * @param db - Firestore database instance
- * @param adminId - ID of the admin
- * @param clinicId - ID of the clinic to remove
- * @param requesterId - ID of the admin making the request
- */
-export async function removeClinicFromManaged(
-  db: Firestore,
-  adminId: string,
-  clinicId: string,
-  requesterId?: string
-): Promise<void> {
-  const admin = await getClinicAdmin(db, adminId);
-  if (!admin) {
-    throw new Error("Clinic admin not found");
-  }
-
-  // Ako je prosleđen requester, proveravamo da li ima prava
-  if (requesterId && requesterId !== adminId) {
-    const requester = await getClinicAdmin(db, requesterId);
-    if (!requester) {
-      throw new Error("Requester admin not found");
-    }
-
-    // Samo owner grupe može da uklanja klinike drugim adminima
-    if (
-      !requester.isGroupOwner ||
-      requester.clinicGroupId !== admin.clinicGroupId
-    ) {
-      throw new Error("Only group owner can remove clinics from other admins");
-    }
-  }
-
-  // Proveravamo da li klinika postoji u listi
-  if (!admin.clinicsManaged.includes(clinicId)) {
-    return; // Klinika nije u listi
-  }
-
-  // Ažuriramo listu klinika
-  await updateClinicAdmin(db, adminId, {
-    clinicsManaged: admin.clinicsManaged.filter((id) => id !== clinicId),
-    clinicsManagedInfo: admin.clinicsManagedInfo.filter(
-      (info) => info.id !== clinicId
-    ),
-  });
-}
-
-/**
- * Gets clinics managed by an admin
- * @param db - Firestore database instance
- * @param adminId - ID of the admin
- * @param clinicService - Service for clinic operations
- * @returns Array of clinics managed by the admin
- */
-export async function getManagedClinics(
-  db: Firestore,
-  adminId: string,
-  clinicService: any
-): Promise<any[]> {
-  const admin = await getClinicAdmin(db, adminId);
-  if (!admin) {
-    throw new Error("Clinic admin not found");
-  }
-
-  if (admin.clinicsManaged.length === 0) {
-    return [];
-  }
-
-  return clinicService.getClinicsByAdmin(adminId);
-}
-
-/**
- * Gets active clinics managed by an admin
- * @param db - Firestore database instance
- * @param adminId - ID of the admin
- * @param clinicService - Service for clinic operations
- * @returns Array of active clinics managed by the admin
- */
-export async function getActiveManagedClinics(
-  db: Firestore,
-  adminId: string,
-  clinicService: any
-): Promise<any[]> {
-  const admin = await getClinicAdmin(db, adminId);
-  if (!admin) {
-    throw new Error("Clinic admin not found");
-  }
-
-  if (admin.clinicsManaged.length === 0) {
-    return [];
-  }
-
-  return clinicService.getActiveClinicsByAdmin(adminId);
-}
-
-/**
- * Syncs an admin's managed clinics info
- * @param db - Firestore database instance
- * @param adminId - ID of the admin
- * @param clinicService - Service for clinic operations
- */
-export async function syncOwnerClinics(
-  db: Firestore,
-  adminId: string,
-  clinicService: any,
-  clinicGroupService: any
-): Promise<void> {
-  const admin = await getClinicAdmin(db, adminId);
-  if (!admin) {
-    throw new Error("Clinic admin not found");
-  }
-
-  // Samo za vlasnike grupa
-  if (!admin.isGroupOwner) {
-    return;
-  }
-
-  // Dohvatamo grupu
-  const group = await clinicGroupService.getClinicGroup(admin.clinicGroupId);
-  if (!group) {
-    throw new Error("Clinic group not found");
-  }
-
-  // Dohvatamo sve klinike grupe
-  const clinics = await clinicService.getClinicsByGroup(admin.clinicGroupId);
-
-  // Ažuriramo listu klinika
-  await updateClinicAdmin(db, adminId, {
-    clinicsManaged: clinics.map((clinic: any) => clinic.id),
-    clinicsManagedInfo: clinics.map((clinic: any) => ({
-      id: clinic.id,
-      featuredPhoto: clinic.featuredPhotos[0] || "",
-      name: clinic.name,
-      description: clinic.description,
-      location: clinic.location,
-      contactInfo: clinic.contactInfo,
-    })),
-  });
-}
+import {
+  collection,
+  doc,
+  getDoc,
+  getDocs,
+  query,
+  where,
+  updateDoc,
+  setDoc,
+  deleteDoc,
+  Timestamp,
+  Firestore,
+  serverTimestamp,
+  FieldValue,
+} from "firebase/firestore";
+import {
+  ClinicAdmin,
+  CreateClinicAdminData,
+  UpdateClinicAdminData,
+  CLINIC_ADMINS_COLLECTION,
+  CreateDefaultClinicGroupData,
+} from "../../../types/clinic";
+import {
+  clinicAdminSchema,
+  createClinicAdminSchema,
+} from "../../../validations/clinic.schema";
+import { z } from "zod";
+
+/**
+ * Creates a new clinic admin
+ * @param db - Firestore database instance
+ * @param data - Admin data
+ * @param clinicGroupService - Service for clinic group operations
+ * @returns The created clinic admin
+ */
+export async function createClinicAdmin(
+  db: Firestore,
+  data: CreateClinicAdminData,
+  clinicGroupService: any
+): Promise<ClinicAdmin> {
+  console.log("[CLINIC_ADMIN] Starting clinic admin creation", {
+    userRef: data.userRef,
+  });
+  console.log("[CLINIC_ADMIN] Input data:", JSON.stringify(data, null, 2));
+
+  // Validacija podataka
+  try {
+    const validatedData = createClinicAdminSchema.parse(data);
+    console.log("[CLINIC_ADMIN] Data validation passed");
+  } catch (validationError) {
+    console.error("[CLINIC_ADMIN] Data validation failed:", validationError);
+    throw validationError;
+  }
+
+  const validatedData = createClinicAdminSchema.parse(data);
+
+  // Proveravamo da li korisnik već ima admin profil
+  console.log("[CLINIC_ADMIN] Checking if user already has an admin profile", {
+    userRef: validatedData.userRef,
+  });
+  try {
+    const existingAdmin = await getClinicAdminByUserRef(
+      db,
+      validatedData.userRef
+    );
+    if (existingAdmin) {
+      console.error("[CLINIC_ADMIN] User already has an admin profile", {
+        adminId: existingAdmin.id,
+      });
+      throw new Error("User already has an admin profile");
+    }
+    console.log("[CLINIC_ADMIN] User does not have an existing admin profile");
+  } catch (error: any) {
+    if (error.message === "User already has an admin profile") {
+      throw error;
+    }
+    console.error("[CLINIC_ADMIN] Error checking for existing admin:", error);
+    throw error;
+  }
+
+  // Ako je owner, kreiramo default grupu ako nije prosleđen groupId
+  let clinicGroupId = validatedData.clinicGroupId;
+  console.log("[CLINIC_ADMIN] Checking clinic group situation", {
+    isGroupOwner: validatedData.isGroupOwner,
+    hasGroupId: !!clinicGroupId,
+  });
+
+  // For owners creating a new group, we'll set the group ID later
+  if (validatedData.isGroupOwner && !clinicGroupId) {
+    console.log("[CLINIC_ADMIN] Owner will be assigned to group later");
+    // Skip creating default group here - will be done in auth service
+  }
+  // Ako nije owner a nemamo groupId, to je greška
+  else if (!validatedData.isGroupOwner && !clinicGroupId) {
+    console.error("[CLINIC_ADMIN] Missing clinic group ID for non-owner admin");
+    throw new Error("Clinic group ID is required for non-owner admins");
+  }
+  // Ako nije owner a imamo groupId, proverimo da li grupa postoji
+  else if (!validatedData.isGroupOwner && clinicGroupId) {
+    console.log("[CLINIC_ADMIN] Checking if specified clinic group exists", {
+      groupId: clinicGroupId,
+    });
+    try {
+      const groupExists = await checkClinicGroupExists(
+        db,
+        clinicGroupId,
+        clinicGroupService
+      );
+      if (!groupExists) {
+        console.error("[CLINIC_ADMIN] Specified clinic group does not exist", {
+          groupId: clinicGroupId,
+        });
+        throw new Error("Specified clinic group does not exist");
+      }
+      console.log("[CLINIC_ADMIN] Specified clinic group exists");
+    } catch (groupCheckError) {
+      console.error(
+        "[CLINIC_ADMIN] Error checking if clinic group exists:",
+        groupCheckError
+      );
+      throw groupCheckError;
+    }
+  }
+
+  console.log("[CLINIC_ADMIN] Preparing admin data object");
+
+  // Allow creating admin without a clinic group for owners
+  const adminData: Omit<ClinicAdmin, "createdAt" | "updatedAt"> & {
+    createdAt: ReturnType<typeof serverTimestamp>;
+    updatedAt: ReturnType<typeof serverTimestamp>;
+  } = {
+    id: doc(collection(db, CLINIC_ADMINS_COLLECTION)).id, // Generate a new ID for the admin document
+    userRef: validatedData.userRef,
+    clinicGroupId: clinicGroupId || "", // Empty string for now if no group ID
+    isGroupOwner: validatedData.isGroupOwner,
+    clinicsManaged: [], // Uvek krećemo od prazne liste
+    clinicsManagedInfo: [], // Empty array for clinic info
+    contactInfo: validatedData.contactInfo,
+    roleTitle: validatedData.roleTitle,
+    isActive: validatedData.isActive,
+    createdAt: serverTimestamp(),
+    updatedAt: serverTimestamp(),
+  };
+
+  // Validacija kompletnog objekta
+  console.log("[CLINIC_ADMIN] Validating complete admin object");
+  try {
+    clinicAdminSchema.parse({
+      ...adminData,
+      createdAt: Timestamp.now(),
+      updatedAt: Timestamp.now(),
+    });
+    console.log("[CLINIC_ADMIN] Admin object validation passed");
+  } catch (schemaError) {
+    console.error(
+      "[CLINIC_ADMIN] Admin object validation failed:",
+      JSON.stringify(schemaError, null, 2)
+    );
+    throw schemaError;
+  }
+
+  // Čuvamo u Firestore
+  console.log("[CLINIC_ADMIN] Saving admin to Firestore", {
+    adminId: adminData.id,
+  });
+  try {
+    await setDoc(doc(db, CLINIC_ADMINS_COLLECTION, adminData.id), adminData);
+    console.log("[CLINIC_ADMIN] Admin saved successfully");
+  } catch (firestoreError) {
+    console.error(
+      "[CLINIC_ADMIN] Error saving admin to Firestore:",
+      firestoreError
+    );
+    throw firestoreError;
+  }
+
+  // Dodajemo admina u grupu
+  if (clinicGroupId) {
+    console.log("[CLINIC_ADMIN] Adding admin to clinic group", {
+      adminId: adminData.id,
+      groupId: clinicGroupId,
+    });
+    try {
+      await clinicGroupService.addAdminToGroup(clinicGroupId, adminData.id);
+      console.log("[CLINIC_ADMIN] Admin added to group successfully");
+    } catch (addToGroupError) {
+      console.error(
+        "[CLINIC_ADMIN] Error adding admin to group:",
+        addToGroupError
+      );
+      throw addToGroupError;
+    }
+  }
+
+  // Vraćamo kreirani objekat
+  console.log("[CLINIC_ADMIN] Retrieving created admin");
+  try {
+    const createdAdmin = await getClinicAdmin(db, adminData.id);
+    if (!createdAdmin) {
+      console.error("[CLINIC_ADMIN] Failed to retrieve created admin");
+      throw new Error("Failed to retrieve created admin");
+    }
+    console.log("[CLINIC_ADMIN] Admin creation completed successfully", {
+      adminId: createdAdmin.id,
+    });
+    return createdAdmin;
+  } catch (retrieveError) {
+    console.error(
+      "[CLINIC_ADMIN] Error retrieving created admin:",
+      retrieveError
+    );
+    throw retrieveError;
+  }
+}
+
+/**
+ * Checks if a clinic group exists
+ * @param db - Firestore database instance
+ * @param groupId - ID of the clinic group
+ * @param clinicGroupService - Service for clinic group operations
+ * @returns Whether the clinic group exists
+ */
+export async function checkClinicGroupExists(
+  db: Firestore,
+  groupId: string,
+  clinicGroupService: any
+): Promise<boolean> {
+  const group = await clinicGroupService.getClinicGroup(groupId);
+  return !!group;
+}
+
+/**
+ * Gets a clinic admin by ID
+ * @param db - Firestore database instance
+ * @param adminId - ID of the admin
+ * @returns The clinic admin or null if not found
+ */
+export async function getClinicAdmin(
+  db: Firestore,
+  adminId: string
+): Promise<ClinicAdmin | null> {
+  const docRef = doc(db, CLINIC_ADMINS_COLLECTION, adminId);
+  const docSnap = await getDoc(docRef);
+
+  if (docSnap.exists()) {
+    return docSnap.data() as ClinicAdmin;
+  }
+
+  return null;
+}
+
+/**
+ * Gets a clinic admin by user reference
+ * @param db - Firestore database instance
+ * @param userRef - User reference
+ * @returns The clinic admin or null if not found
+ */
+export async function getClinicAdminByUserRef(
+  db: Firestore,
+  userRef: string
+): Promise<ClinicAdmin | null> {
+  const q = query(
+    collection(db, CLINIC_ADMINS_COLLECTION),
+    where("userRef", "==", userRef)
+  );
+
+  const querySnapshot = await getDocs(q);
+  if (querySnapshot.empty) {
+    return null;
+  }
+
+  return querySnapshot.docs[0].data() as ClinicAdmin;
+}
+
+/**
+ * Gets all clinic admins in a group
+ * @param db - Firestore database instance
+ * @param clinicGroupId - ID of the clinic group
+ * @returns Array of clinic admins in the group
+ */
+export async function getClinicAdminsByGroup(
+  db: Firestore,
+  clinicGroupId: string
+): Promise<ClinicAdmin[]> {
+  const q = query(
+    collection(db, CLINIC_ADMINS_COLLECTION),
+    where("clinicGroupId", "==", clinicGroupId)
+  );
+
+  const querySnapshot = await getDocs(q);
+  return querySnapshot.docs.map((doc) => doc.data() as ClinicAdmin);
+}
+
+/**
+ * Updates a clinic admin
+ * @param db - Firestore database instance
+ * @param adminId - ID of the admin to update
+ * @param data - Data to update
+ * @returns The updated clinic admin
+ */
+export async function updateClinicAdmin(
+  db: Firestore,
+  adminId: string,
+  data: UpdateClinicAdminData
+): Promise<ClinicAdmin> {
+  const admin = await getClinicAdmin(db, adminId);
+  if (!admin) {
+    throw new Error("Clinic admin not found");
+  }
+
+  // Ažuriramo podatke
+  const updatedData = {
+    ...data,
+    updatedAt: serverTimestamp(),
+  };
+
+  await updateDoc(doc(db, CLINIC_ADMINS_COLLECTION, adminId), updatedData);
+
+  // Vraćamo ažurirane podatke
+  const updatedAdmin = await getClinicAdmin(db, adminId);
+  if (!updatedAdmin) {
+    throw new Error("Failed to retrieve updated admin");
+  }
+
+  return updatedAdmin;
+}
+
+/**
+ * Deletes a clinic admin
+ * @param db - Firestore database instance
+ * @param adminId - ID of the admin to delete
+ */
+export async function deleteClinicAdmin(
+  db: Firestore,
+  adminId: string
+): Promise<void> {
+  const admin = await getClinicAdmin(db, adminId);
+  if (!admin) {
+    throw new Error("Clinic admin not found");
+  }
+
+  await deleteDoc(doc(db, CLINIC_ADMINS_COLLECTION, adminId));
+}
+
+/**
+ * Adds a clinic to an admin's managed clinics
+ * @param db - Firestore database instance
+ * @param adminId - ID of the admin
+ * @param clinicId - ID of the clinic to add
+ * @param requesterId - ID of the admin making the request
+ * @param clinicService - Service for clinic operations
+ */
+export async function addClinicToManaged(
+  db: Firestore,
+  adminId: string,
+  clinicId: string,
+  requesterId?: string,
+  clinicService?: any
+): Promise<void> {
+  const admin = await getClinicAdmin(db, adminId);
+  if (!admin) {
+    throw new Error("Clinic admin not found");
+  }
+
+  // Ako je prosleđen requester, proveravamo da li ima prava
+  if (requesterId && requesterId !== adminId) {
+    const requester = await getClinicAdmin(db, requesterId);
+    if (!requester) {
+      throw new Error("Requester admin not found");
+    }
+
+    // Samo owner grupe može da dodaje klinike drugim adminima
+    if (
+      !requester.isGroupOwner ||
+      requester.clinicGroupId !== admin.clinicGroupId
+    ) {
+      throw new Error("Only group owner can add clinics to other admins");
+    }
+  }
+
+  // Proveravamo da li klinika već postoji u listi
+  if (admin.clinicsManaged.includes(clinicId)) {
+    return; // Klinika je već u listi
+  }
+
+  // Ažuriramo listu klinika
+  await updateClinicAdmin(db, adminId, {
+    clinicsManaged: [...admin.clinicsManaged, clinicId],
+  });
+
+  // Ako imamo clinicService, dohvatamo info o klinici i dodajemo ga u clinicsManagedInfo
+  if (clinicService) {
+    const clinic = await clinicService.getClinic(clinicId);
+    if (clinic) {
+      await updateClinicAdmin(db, adminId, {
+        clinicsManagedInfo: [
+          ...admin.clinicsManagedInfo,
+          {
+            id: clinic.id,
+            featuredPhoto: clinic.featuredPhotos[0] || "",
+            name: clinic.name,
+            description: clinic.description,
+            location: clinic.location,
+            contactInfo: clinic.contactInfo,
+          },
+        ],
+      });
+    }
+  }
+}
+
+/**
+ * Removes a clinic from an admin's managed clinics
+ * @param db - Firestore database instance
+ * @param adminId - ID of the admin
+ * @param clinicId - ID of the clinic to remove
+ * @param requesterId - ID of the admin making the request
+ */
+export async function removeClinicFromManaged(
+  db: Firestore,
+  adminId: string,
+  clinicId: string,
+  requesterId?: string
+): Promise<void> {
+  const admin = await getClinicAdmin(db, adminId);
+  if (!admin) {
+    throw new Error("Clinic admin not found");
+  }
+
+  // Ako je prosleđen requester, proveravamo da li ima prava
+  if (requesterId && requesterId !== adminId) {
+    const requester = await getClinicAdmin(db, requesterId);
+    if (!requester) {
+      throw new Error("Requester admin not found");
+    }
+
+    // Samo owner grupe može da uklanja klinike drugim adminima
+    if (
+      !requester.isGroupOwner ||
+      requester.clinicGroupId !== admin.clinicGroupId
+    ) {
+      throw new Error("Only group owner can remove clinics from other admins");
+    }
+  }
+
+  // Proveravamo da li klinika postoji u listi
+  if (!admin.clinicsManaged.includes(clinicId)) {
+    return; // Klinika nije u listi
+  }
+
+  // Ažuriramo listu klinika
+  await updateClinicAdmin(db, adminId, {
+    clinicsManaged: admin.clinicsManaged.filter((id) => id !== clinicId),
+    clinicsManagedInfo: admin.clinicsManagedInfo.filter(
+      (info) => info.id !== clinicId
+    ),
+  });
+}
+
+/**
+ * Gets clinics managed by an admin
+ * @param db - Firestore database instance
+ * @param adminId - ID of the admin
+ * @param clinicService - Service for clinic operations
+ * @returns Array of clinics managed by the admin
+ */
+export async function getManagedClinics(
+  db: Firestore,
+  adminId: string,
+  clinicService: any
+): Promise<any[]> {
+  const admin = await getClinicAdmin(db, adminId);
+  if (!admin) {
+    throw new Error("Clinic admin not found");
+  }
+
+  if (admin.clinicsManaged.length === 0) {
+    return [];
+  }
+
+  return clinicService.getClinicsByAdmin(adminId);
+}
+
+/**
+ * Gets active clinics managed by an admin
+ * @param db - Firestore database instance
+ * @param adminId - ID of the admin
+ * @param clinicService - Service for clinic operations
+ * @returns Array of active clinics managed by the admin
+ */
+export async function getActiveManagedClinics(
+  db: Firestore,
+  adminId: string,
+  clinicService: any
+): Promise<any[]> {
+  const admin = await getClinicAdmin(db, adminId);
+  if (!admin) {
+    throw new Error("Clinic admin not found");
+  }
+
+  if (admin.clinicsManaged.length === 0) {
+    return [];
+  }
+
+  return clinicService.getActiveClinicsByAdmin(adminId);
+}
+
+/**
+ * Syncs an admin's managed clinics info
+ * @param db - Firestore database instance
+ * @param adminId - ID of the admin
+ * @param clinicService - Service for clinic operations
+ */
+export async function syncOwnerClinics(
+  db: Firestore,
+  adminId: string,
+  clinicService: any,
+  clinicGroupService: any
+): Promise<void> {
+  const admin = await getClinicAdmin(db, adminId);
+  if (!admin) {
+    throw new Error("Clinic admin not found");
+  }
+
+  // Samo za vlasnike grupa
+  if (!admin.isGroupOwner) {
+    return;
+  }
+
+  // Dohvatamo grupu
+  const group = await clinicGroupService.getClinicGroup(admin.clinicGroupId);
+  if (!group) {
+    throw new Error("Clinic group not found");
+  }
+
+  // Dohvatamo sve klinike grupe
+  const clinics = await clinicService.getClinicsByGroup(admin.clinicGroupId);
+
+  // Ažuriramo listu klinika
+  await updateClinicAdmin(db, adminId, {
+    clinicsManaged: clinics.map((clinic: any) => clinic.id),
+    clinicsManagedInfo: clinics.map((clinic: any) => ({
+      id: clinic.id,
+      featuredPhoto: clinic.featuredPhotos[0] || "",
+      name: clinic.name,
+      description: clinic.description,
+      location: clinic.location,
+      contactInfo: clinic.contactInfo,
+    })),
+  });
+}