@blackcode_sa/metaestetics-api 1.12.65 → 1.12.67

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

@@ -1,646 +1,646 @@
-import {
-  collection,
-  doc,
-  getDoc,
-  getDocs,
-  query,
-  where,
-  updateDoc,
-  setDoc,
-  deleteDoc,
-  Timestamp,
-  Firestore,
-  serverTimestamp,
-} from "firebase/firestore";
-import { getStorage, ref, uploadBytes, getDownloadURL } from "firebase/storage";
-import {
-  ClinicGroup,
-  CreateClinicGroupData,
-  CLINIC_GROUPS_COLLECTION,
-  AdminToken,
-  AdminTokenStatus,
-  CreateAdminTokenData,
-  SubscriptionModel,
-} from "../../../types/clinic";
-import { geohashForLocation } from "geofire-common";
-import {
-  clinicGroupSchema,
-  createClinicGroupSchema,
-} from "../../../validations/clinic.schema";
-import { z } from "zod";
-import { uploadPhoto } from "./photos.utils";
-import { FirebaseApp } from "firebase/app";
-
-/**
- * Generates a unique ID for documents
- * Format: xxxxxxxxxxxx-timestamp
- * Where x is a random character (number or letter)
- */
-function generateId(): string {
-  const chars =
-    "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
-  const timestamp = Date.now().toString(36);
-  const randomPart = Array.from({ length: 12 }, () =>
-    chars.charAt(Math.floor(Math.random() * chars.length))
-  ).join("");
-
-  return `${randomPart}-${timestamp}`;
-}
-
-/**
- * Creates a new clinic group
- * @param db - Firestore database instance
- * @param data - Clinic group data
- * @param ownerId - ID of the owner
- * @param isDefault - Whether this is a default group
- * @param clinicAdminService - Service for clinic admin operations
- * @param app - Firebase app instance
- * @returns The created clinic group
- */
-export async function createClinicGroup(
-  db: Firestore,
-  data: CreateClinicGroupData,
-  ownerId: string,
-  isDefault: boolean = false,
-  clinicAdminService: any,
-  app: FirebaseApp
-): Promise<ClinicGroup> {
-  console.log("[CLINIC_GROUP] Starting clinic group creation", {
-    ownerId,
-    isDefault,
-  });
-  console.log("[CLINIC_GROUP] Input data:", JSON.stringify(data, null, 2));
-
-  let validatedData: CreateClinicGroupData;
-  // Validacija podataka
-  try {
-    validatedData = createClinicGroupSchema.parse(data);
-    console.log("[CLINIC_GROUP] Data validation passed");
-  } catch (validationError) {
-    console.error("[CLINIC_GROUP] Data validation failed:", validationError);
-    throw validationError;
-  }
-
-  // Proveravamo da li owner postoji i da li je clinic admin
-  try {
-    console.log("[CLINIC_GROUP] Checking if owner exists", { ownerId });
-    // Skip owner verification for default groups since the admin profile doesn't exist yet
-    if (isDefault) {
-      console.log(
-        "[CLINIC_GROUP] Skipping owner verification for default group creation"
-      );
-    } else {
-      const owner = await clinicAdminService.getClinicAdmin(ownerId);
-      if (!owner) {
-        console.error(
-          "[CLINIC_GROUP] Owner not found or is not a clinic admin",
-          {
-            ownerId,
-          }
-        );
-        throw new Error("Owner not found or is not a clinic admin");
-      }
-      console.log("[CLINIC_GROUP] Owner verified as clinic admin");
-    }
-  } catch (ownerError) {
-    console.error("[CLINIC_GROUP] Error verifying owner:", ownerError);
-    throw ownerError;
-  }
-
-  // Generišemo geohash za lokaciju
-  console.log("[CLINIC_GROUP] Generating geohash for location");
-  if (validatedData.hqLocation) {
-    try {
-      validatedData.hqLocation.geohash = geohashForLocation([
-        validatedData.hqLocation.latitude,
-        validatedData.hqLocation.longitude,
-      ]);
-      console.log("[CLINIC_GROUP] Geohash generated successfully", {
-        geohash: validatedData.hqLocation.geohash,
-      });
-    } catch (geohashError) {
-      console.error("[CLINIC_GROUP] Error generating geohash:", geohashError);
-      throw geohashError;
-    }
-  }
-
-  const now = Timestamp.now();
-  console.log("[CLINIC_GROUP] Preparing clinic group data object");
-
-  // Generate a unique ID for the clinic group
-  const groupId = doc(collection(db, CLINIC_GROUPS_COLLECTION)).id;
-
-  // Log the logo value to debug null vs undefined issue
-  console.log("[CLINIC_GROUP] Logo value:", {
-    logoValue: validatedData.logo,
-    logoType: validatedData.logo === null ? "null" : typeof validatedData.logo,
-  });
-
-  // Handle logo upload if provided
-  let logoUrl = await uploadPhoto(
-    validatedData.logo || null,
-    "clinic-groups",
-    groupId,
-    "logo",
-    app
-  );
-  console.log("[CLINIC_GROUP] Logo processed", { logoUrl });
-
-  const groupData: ClinicGroup = {
-    ...validatedData,
-    id: groupId,
-    name: validatedData.name,
-    logo: logoUrl, // Use the uploaded logo URL or the original value
-    description: validatedData.description || "",
-    hqLocation: validatedData.hqLocation,
-    contactInfo: validatedData.contactInfo,
-    contactPerson: validatedData.contactPerson,
-    subscriptionModel:
-      validatedData.subscriptionModel || SubscriptionModel.NO_SUBSCRIPTION,
-    clinics: [],
-    clinicsInfo: [],
-    admins: [ownerId],
-    adminsInfo: [],
-    adminTokens: [],
-    ownerId,
-    createdAt: now,
-    updatedAt: now,
-    isActive: true,
-  };
-
-  try {
-    // Validiramo kompletan objekat
-    console.log("[CLINIC_GROUP] Validating complete clinic group object");
-    try {
-      clinicGroupSchema.parse(groupData);
-      console.log("[CLINIC_GROUP] Clinic group validation passed");
-    } catch (schemaError) {
-      console.error(
-        "[CLINIC_GROUP] Clinic group validation failed:",
-        JSON.stringify(schemaError, null, 2)
-      );
-      throw schemaError;
-    }
-
-    // Čuvamo u Firestore
-    console.log("[CLINIC_GROUP] Saving clinic group to Firestore", {
-      groupId: groupData.id,
-    });
-    try {
-      await setDoc(doc(db, CLINIC_GROUPS_COLLECTION, groupData.id), groupData);
-      console.log("[CLINIC_GROUP] Clinic group saved successfully");
-    } catch (firestoreError) {
-      console.error(
-        "[CLINIC_GROUP] Error saving to Firestore:",
-        firestoreError
-      );
-      throw firestoreError;
-    }
-
-    // Ažuriramo clinic admin profil vlasnika
-    console.log("[CLINIC_GROUP] Updating clinic admin profile for owner", {
-      ownerId,
-    });
-    try {
-      await clinicAdminService.updateClinicAdmin(ownerId, {
-        clinicGroupId: groupData.id,
-        isGroupOwner: true,
-      });
-      console.log("[CLINIC_GROUP] Clinic admin profile updated successfully");
-    } catch (updateError) {
-      console.error(
-        "[CLINIC_GROUP] Error updating clinic admin profile:",
-        updateError
-      );
-      throw updateError;
-    }
-
-    console.log("[CLINIC_GROUP] Clinic group creation completed successfully", {
-      groupId: groupData.id,
-      groupName: groupData.name,
-    });
-    return groupData;
-  } catch (error) {
-    if (error instanceof z.ZodError) {
-      console.error(
-        "[CLINIC_GROUP] Zod validation error:",
-        JSON.stringify(error.errors, null, 2)
-      );
-      throw new Error("Invalid clinic group data: " + error.message);
-    }
-    console.error(
-      "[CLINIC_GROUP] Unhandled error in createClinicGroup:",
-      error
-    );
-    throw error;
-  }
-}
-
-/**
- * Gets a clinic group by ID
- * @param db - Firestore database instance
- * @param groupId - ID of the clinic group
- * @returns The clinic group or null if not found
- */
-export async function getClinicGroup(
-  db: Firestore,
-  groupId: string
-): Promise<ClinicGroup | null> {
-  const docRef = doc(db, CLINIC_GROUPS_COLLECTION, groupId);
-  const docSnap = await getDoc(docRef);
-
-  if (docSnap.exists()) {
-    return docSnap.data() as ClinicGroup;
-  }
-
-  return null;
-}
-
-/**
- * Gets all active clinic groups
- * @param db - Firestore database instance
- * @returns Array of active clinic groups
- */
-export async function getAllActiveGroups(
-  db: Firestore
-): Promise<ClinicGroup[]> {
-  const q = query(
-    collection(db, CLINIC_GROUPS_COLLECTION),
-    where("isActive", "==", true)
-  );
-
-  const querySnapshot = await getDocs(q);
-  return querySnapshot.docs.map((doc) => doc.data() as ClinicGroup);
-}
-
-/**
- * Updates a clinic group
- * @param db - Firestore database instance
- * @param groupId - ID of the clinic group
- * @param data - Data to update
- * @param app - Firebase app instance
- * @returns The updated clinic group
- */
-export async function updateClinicGroup(
-  db: Firestore,
-  groupId: string,
-  data: Partial<ClinicGroup>,
-  app: FirebaseApp
-): Promise<ClinicGroup> {
-  console.log("[CLINIC_GROUP] Updating clinic group", { groupId });
-
-  const group = await getClinicGroup(db, groupId);
-  if (!group) {
-    console.error("[CLINIC_GROUP] Clinic group not found", { groupId });
-    throw new Error("Clinic group not found");
-  }
-
-  // Process logo if it's a data URL
-  let updatedData = { ...data };
-
-  if (
-    data.logo &&
-    typeof data.logo === "string" &&
-    data.logo.startsWith("data:")
-  ) {
-    console.log("[CLINIC_GROUP] Processing logo for update");
-    try {
-      const logoUrl = await uploadPhoto(
-        data.logo,
-        "clinic-groups",
-        groupId,
-        "logo",
-        app
-      );
-      console.log("[CLINIC_GROUP] Logo processed for update", { logoUrl });
-
-      // Replace the data URL with the uploaded URL
-      updatedData.logo = logoUrl;
-    } catch (error) {
-      console.error("[CLINIC_GROUP] Error processing logo for update:", error);
-      // Continue with update even if logo upload fails
-    }
-  }
-
-  // Add timestamp
-  updatedData = {
-    ...updatedData,
-    updatedAt: Timestamp.now(),
-  };
-
-  console.log("[CLINIC_GROUP] Updating clinic group in Firestore");
-  await updateDoc(doc(db, CLINIC_GROUPS_COLLECTION, groupId), updatedData);
-  console.log("[CLINIC_GROUP] Clinic group updated successfully");
-
-  // Return updated data
-  const updatedGroup = await getClinicGroup(db, groupId);
-  if (!updatedGroup) {
-    console.error("[CLINIC_GROUP] Failed to retrieve updated clinic group");
-    throw new Error("Failed to retrieve updated clinic group");
-  }
-
-  return updatedGroup;
-}
-
-/**
- * Adds an admin to a clinic group
- * @param db - Firestore database instance
- * @param groupId - ID of the clinic group
- * @param adminId - ID of the admin to add (this is the admin document ID, not the user UID)
- * @param app - Firebase app instance
- */
-export async function addAdminToGroup(
-  db: Firestore,
-  groupId: string,
-  adminId: string,
-  app: FirebaseApp
-): Promise<void> {
-  console.log("[CLINIC_GROUP] Adding admin to group", { groupId, adminId });
-
-  try {
-    const group = await getClinicGroup(db, groupId);
-    if (!group) {
-      console.error("[CLINIC_GROUP] Clinic group not found", { groupId });
-      throw new Error("Clinic group not found");
-    }
-
-    if (group.admins.includes(adminId)) {
-      console.log("[CLINIC_GROUP] Admin is already in the group", {
-        adminId,
-        groupId,
-      });
-      return; // Admin is already in the group
-    }
-
-    console.log("[CLINIC_GROUP] Updating group with new admin");
-    await updateClinicGroup(
-      db,
-      groupId,
-      {
-        admins: [...group.admins, adminId],
-      },
-      app
-    );
-    console.log("[CLINIC_GROUP] Admin added to group successfully");
-  } catch (error) {
-    console.error("[CLINIC_GROUP] Error adding admin to group:", error);
-    throw error;
-  }
-}
-
-/**
- * Removes an admin from a clinic group
- * @param db - Firestore database instance
- * @param groupId - ID of the clinic group
- * @param adminId - ID of the admin to remove
- * @param app - Firebase app instance
- */
-export async function removeAdminFromGroup(
-  db: Firestore,
-  groupId: string,
-  adminId: string,
-  app: FirebaseApp
-): Promise<void> {
-  const group = await getClinicGroup(db, groupId);
-  if (!group) {
-    throw new Error("Clinic group not found");
-  }
-
-  if (group.ownerId === adminId) {
-    throw new Error("Cannot remove the owner from the group");
-  }
-
-  if (!group.admins.includes(adminId)) {
-    return; // Admin is not in the group
-  }
-
-  await updateClinicGroup(
-    db,
-    groupId,
-    {
-      admins: group.admins.filter((id) => id !== adminId),
-    },
-    app
-  );
-}
-
-/**
- * Deactivates a clinic group
- * @param db - Firestore database instance
- * @param groupId - ID of the clinic group
- * @param app - Firebase app instance
- */
-export async function deactivateClinicGroup(
-  db: Firestore,
-  groupId: string,
-  app: FirebaseApp
-): Promise<void> {
-  const group = await getClinicGroup(db, groupId);
-  if (!group) {
-    throw new Error("Clinic group not found");
-  }
-
-  await updateClinicGroup(
-    db,
-    groupId,
-    {
-      isActive: false,
-    },
-    app
-  );
-}
-
-/**
- * Creates an admin token for a clinic group
- * @param db - Firestore database instance
- * @param groupId - ID of the clinic group
- * @param creatorAdminId - ID of the admin creating the token
- * @param app - Firebase app instance
- * @param data - Token data
- * @returns The created admin token
- */
-export async function createAdminToken(
-  db: Firestore,
-  groupId: string,
-  creatorAdminId: string,
-  app: FirebaseApp,
-  data?: CreateAdminTokenData
-): Promise<AdminToken> {
-  const group = await getClinicGroup(db, groupId);
-  if (!group) {
-    throw new Error("Clinic group not found");
-  }
-
-  // Proveravamo da li admin pripada grupi
-  if (!group.admins.includes(creatorAdminId)) {
-    throw new Error("Admin does not belong to this clinic group");
-  }
-
-  const now = Timestamp.now();
-  const expiresInDays = data?.expiresInDays || 7; // Default 7 days
-  const email = data?.email || null;
-  const expiresAt = new Timestamp(
-    now.seconds + expiresInDays * 24 * 60 * 60,
-    now.nanoseconds
-  );
-
-  const token: AdminToken = {
-    id: generateId(),
-    token: generateId(),
-    status: AdminTokenStatus.ACTIVE,
-    email,
-    createdAt: now,
-    expiresAt,
-  };
-
-  // Dodajemo token u grupu
-  // Ovo treba promeniti, staviti admin tokene u sub-kolekciju u klinickoj grupi
-  await updateClinicGroup(
-    db,
-    groupId,
-    {
-      adminTokens: [...group.adminTokens, token],
-    },
-    app
-  );
-
-  return token;
-}
-
-/**
- * Verifies and uses an admin token
- * @param db - Firestore database instance
- * @param groupId - ID of the clinic group
- * @param token - Token to verify
- * @param userRef - User reference
- * @param app - Firebase app instance
- * @returns Whether the token was successfully used
- */
-export async function verifyAndUseAdminToken(
-  db: Firestore,
-  groupId: string,
-  token: string,
-  userRef: string,
-  app: FirebaseApp
-): Promise<boolean> {
-  const group = await getClinicGroup(db, groupId);
-  if (!group) {
-    throw new Error("Clinic group not found");
-  }
-
-  const adminToken = group.adminTokens.find((t) => t.token === token);
-  if (!adminToken) {
-    throw new Error("Admin token not found");
-  }
-
-  if (adminToken.status !== AdminTokenStatus.ACTIVE) {
-    throw new Error("Admin token is not active");
-  }
-
-  const now = Timestamp.now();
-  if (adminToken.expiresAt.seconds < now.seconds) {
-    // Token je istekao, ažuriramo status
-    const updatedTokens = group.adminTokens.map((t) =>
-      t.id === adminToken.id ? { ...t, status: AdminTokenStatus.EXPIRED } : t
-    );
-
-    await updateClinicGroup(
-      db,
-      groupId,
-      {
-        adminTokens: updatedTokens,
-      },
-      app
-    );
-
-    throw new Error("Admin token has expired");
-  }
-
-  // Token je validan, ažuriramo status
-  const updatedTokens = group.adminTokens.map((t) =>
-    t.id === adminToken.id
-      ? {
-          ...t,
-          status: AdminTokenStatus.USED,
-          usedByUserRef: userRef,
-        }
-      : t
-  );
-
-  await updateClinicGroup(
-    db,
-    groupId,
-    {
-      adminTokens: updatedTokens,
-    },
-    app
-  );
-
-  return true;
-}
-
-/**
- * Deletes an admin token
- * @param db - Firestore database instance
- * @param groupId - ID of the clinic group
- * @param tokenId - ID of the token to delete
- * @param adminId - ID of the admin making the deletion
- * @param app - Firebase app instance
- */
-export async function deleteAdminToken(
-  db: Firestore,
-  groupId: string,
-  tokenId: string,
-  adminId: string,
-  app: FirebaseApp
-): Promise<void> {
-  const group = await getClinicGroup(db, groupId);
-  if (!group) {
-    throw new Error("Clinic group not found");
-  }
-
-  // Proveravamo da li admin pripada grupi
-  if (!group.admins.includes(adminId)) {
-    throw new Error("Admin does not belong to this clinic group");
-  }
-
-  // Uklanjamo token
-  const updatedTokens = group.adminTokens.filter((t) => t.id !== tokenId);
-
-  await updateClinicGroup(
-    db,
-    groupId,
-    {
-      adminTokens: updatedTokens,
-    },
-    app
-  );
-}
-
-/**
- * Gets active admin tokens for a clinic group
- * @param db - Firestore database instance
- * @param groupId - ID of the clinic group
- * @param adminId - ID of the admin requesting the tokens
- * @param app - Firebase app instance (not used but included for consistency)
- * @returns Array of active admin tokens
- */
-export async function getActiveAdminTokens(
-  db: Firestore,
-  groupId: string,
-  adminId: string,
-  app: FirebaseApp
-): Promise<AdminToken[]> {
-  const group = await getClinicGroup(db, groupId);
-  if (!group) {
-    throw new Error("Clinic group not found");
-  }
-
-  // Proveravamo da li admin pripada grupi
-  if (!group.admins.includes(adminId)) {
-    throw new Error("Admin does not belong to this clinic group");
-  }
-
-  // Vraćamo samo aktivne tokene
-  return group.adminTokens.filter((t) => t.status === AdminTokenStatus.ACTIVE);
-}
+import {
+  collection,
+  doc,
+  getDoc,
+  getDocs,
+  query,
+  where,
+  updateDoc,
+  setDoc,
+  deleteDoc,
+  Timestamp,
+  Firestore,
+  serverTimestamp,
+} from "firebase/firestore";
+import { getStorage, ref, uploadBytes, getDownloadURL } from "firebase/storage";
+import {
+  ClinicGroup,
+  CreateClinicGroupData,
+  CLINIC_GROUPS_COLLECTION,
+  AdminToken,
+  AdminTokenStatus,
+  CreateAdminTokenData,
+  SubscriptionModel,
+} from "../../../types/clinic";
+import { geohashForLocation } from "geofire-common";
+import {
+  clinicGroupSchema,
+  createClinicGroupSchema,
+} from "../../../validations/clinic.schema";
+import { z } from "zod";
+import { uploadPhoto } from "./photos.utils";
+import { FirebaseApp } from "firebase/app";
+
+/**
+ * Generates a unique ID for documents
+ * Format: xxxxxxxxxxxx-timestamp
+ * Where x is a random character (number or letter)
+ */
+function generateId(): string {
+  const chars =
+    "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+  const timestamp = Date.now().toString(36);
+  const randomPart = Array.from({ length: 12 }, () =>
+    chars.charAt(Math.floor(Math.random() * chars.length))
+  ).join("");
+
+  return `${randomPart}-${timestamp}`;
+}
+
+/**
+ * Creates a new clinic group
+ * @param db - Firestore database instance
+ * @param data - Clinic group data
+ * @param ownerId - ID of the owner
+ * @param isDefault - Whether this is a default group
+ * @param clinicAdminService - Service for clinic admin operations
+ * @param app - Firebase app instance
+ * @returns The created clinic group
+ */
+export async function createClinicGroup(
+  db: Firestore,
+  data: CreateClinicGroupData,
+  ownerId: string,
+  isDefault: boolean = false,
+  clinicAdminService: any,
+  app: FirebaseApp
+): Promise<ClinicGroup> {
+  console.log("[CLINIC_GROUP] Starting clinic group creation", {
+    ownerId,
+    isDefault,
+  });
+  console.log("[CLINIC_GROUP] Input data:", JSON.stringify(data, null, 2));
+
+  let validatedData: CreateClinicGroupData;
+  // Validacija podataka
+  try {
+    validatedData = createClinicGroupSchema.parse(data);
+    console.log("[CLINIC_GROUP] Data validation passed");
+  } catch (validationError) {
+    console.error("[CLINIC_GROUP] Data validation failed:", validationError);
+    throw validationError;
+  }
+
+  // Proveravamo da li owner postoji i da li je clinic admin
+  try {
+    console.log("[CLINIC_GROUP] Checking if owner exists", { ownerId });
+    // Skip owner verification for default groups since the admin profile doesn't exist yet
+    if (isDefault) {
+      console.log(
+        "[CLINIC_GROUP] Skipping owner verification for default group creation"
+      );
+    } else {
+      const owner = await clinicAdminService.getClinicAdmin(ownerId);
+      if (!owner) {
+        console.error(
+          "[CLINIC_GROUP] Owner not found or is not a clinic admin",
+          {
+            ownerId,
+          }
+        );
+        throw new Error("Owner not found or is not a clinic admin");
+      }
+      console.log("[CLINIC_GROUP] Owner verified as clinic admin");
+    }
+  } catch (ownerError) {
+    console.error("[CLINIC_GROUP] Error verifying owner:", ownerError);
+    throw ownerError;
+  }
+
+  // Generišemo geohash za lokaciju
+  console.log("[CLINIC_GROUP] Generating geohash for location");
+  if (validatedData.hqLocation) {
+    try {
+      validatedData.hqLocation.geohash = geohashForLocation([
+        validatedData.hqLocation.latitude,
+        validatedData.hqLocation.longitude,
+      ]);
+      console.log("[CLINIC_GROUP] Geohash generated successfully", {
+        geohash: validatedData.hqLocation.geohash,
+      });
+    } catch (geohashError) {
+      console.error("[CLINIC_GROUP] Error generating geohash:", geohashError);
+      throw geohashError;
+    }
+  }
+
+  const now = Timestamp.now();
+  console.log("[CLINIC_GROUP] Preparing clinic group data object");
+
+  // Generate a unique ID for the clinic group
+  const groupId = doc(collection(db, CLINIC_GROUPS_COLLECTION)).id;
+
+  // Log the logo value to debug null vs undefined issue
+  console.log("[CLINIC_GROUP] Logo value:", {
+    logoValue: validatedData.logo,
+    logoType: validatedData.logo === null ? "null" : typeof validatedData.logo,
+  });
+
+  // Handle logo upload if provided
+  let logoUrl = await uploadPhoto(
+    validatedData.logo || null,
+    "clinic-groups",
+    groupId,
+    "logo",
+    app
+  );
+  console.log("[CLINIC_GROUP] Logo processed", { logoUrl });
+
+  const groupData: ClinicGroup = {
+    ...validatedData,
+    id: groupId,
+    name: validatedData.name,
+    logo: logoUrl, // Use the uploaded logo URL or the original value
+    description: validatedData.description || "",
+    hqLocation: validatedData.hqLocation,
+    contactInfo: validatedData.contactInfo,
+    contactPerson: validatedData.contactPerson,
+    subscriptionModel:
+      validatedData.subscriptionModel || SubscriptionModel.NO_SUBSCRIPTION,
+    clinics: [],
+    clinicsInfo: [],
+    admins: [ownerId],
+    adminsInfo: [],
+    adminTokens: [],
+    ownerId,
+    createdAt: now,
+    updatedAt: now,
+    isActive: true,
+  };
+
+  try {
+    // Validiramo kompletan objekat
+    console.log("[CLINIC_GROUP] Validating complete clinic group object");
+    try {
+      clinicGroupSchema.parse(groupData);
+      console.log("[CLINIC_GROUP] Clinic group validation passed");
+    } catch (schemaError) {
+      console.error(
+        "[CLINIC_GROUP] Clinic group validation failed:",
+        JSON.stringify(schemaError, null, 2)
+      );
+      throw schemaError;
+    }
+
+    // Čuvamo u Firestore
+    console.log("[CLINIC_GROUP] Saving clinic group to Firestore", {
+      groupId: groupData.id,
+    });
+    try {
+      await setDoc(doc(db, CLINIC_GROUPS_COLLECTION, groupData.id), groupData);
+      console.log("[CLINIC_GROUP] Clinic group saved successfully");
+    } catch (firestoreError) {
+      console.error(
+        "[CLINIC_GROUP] Error saving to Firestore:",
+        firestoreError
+      );
+      throw firestoreError;
+    }
+
+    // Ažuriramo clinic admin profil vlasnika
+    console.log("[CLINIC_GROUP] Updating clinic admin profile for owner", {
+      ownerId,
+    });
+    try {
+      await clinicAdminService.updateClinicAdmin(ownerId, {
+        clinicGroupId: groupData.id,
+        isGroupOwner: true,
+      });
+      console.log("[CLINIC_GROUP] Clinic admin profile updated successfully");
+    } catch (updateError) {
+      console.error(
+        "[CLINIC_GROUP] Error updating clinic admin profile:",
+        updateError
+      );
+      throw updateError;
+    }
+
+    console.log("[CLINIC_GROUP] Clinic group creation completed successfully", {
+      groupId: groupData.id,
+      groupName: groupData.name,
+    });
+    return groupData;
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      console.error(
+        "[CLINIC_GROUP] Zod validation error:",
+        JSON.stringify(error.errors, null, 2)
+      );
+      throw new Error("Invalid clinic group data: " + error.message);
+    }
+    console.error(
+      "[CLINIC_GROUP] Unhandled error in createClinicGroup:",
+      error
+    );
+    throw error;
+  }
+}
+
+/**
+ * Gets a clinic group by ID
+ * @param db - Firestore database instance
+ * @param groupId - ID of the clinic group
+ * @returns The clinic group or null if not found
+ */
+export async function getClinicGroup(
+  db: Firestore,
+  groupId: string
+): Promise<ClinicGroup | null> {
+  const docRef = doc(db, CLINIC_GROUPS_COLLECTION, groupId);
+  const docSnap = await getDoc(docRef);
+
+  if (docSnap.exists()) {
+    return docSnap.data() as ClinicGroup;
+  }
+
+  return null;
+}
+
+/**
+ * Gets all active clinic groups
+ * @param db - Firestore database instance
+ * @returns Array of active clinic groups
+ */
+export async function getAllActiveGroups(
+  db: Firestore
+): Promise<ClinicGroup[]> {
+  const q = query(
+    collection(db, CLINIC_GROUPS_COLLECTION),
+    where("isActive", "==", true)
+  );
+
+  const querySnapshot = await getDocs(q);
+  return querySnapshot.docs.map((doc) => doc.data() as ClinicGroup);
+}
+
+/**
+ * Updates a clinic group
+ * @param db - Firestore database instance
+ * @param groupId - ID of the clinic group
+ * @param data - Data to update
+ * @param app - Firebase app instance
+ * @returns The updated clinic group
+ */
+export async function updateClinicGroup(
+  db: Firestore,
+  groupId: string,
+  data: Partial<ClinicGroup>,
+  app: FirebaseApp
+): Promise<ClinicGroup> {
+  console.log("[CLINIC_GROUP] Updating clinic group", { groupId });
+
+  const group = await getClinicGroup(db, groupId);
+  if (!group) {
+    console.error("[CLINIC_GROUP] Clinic group not found", { groupId });
+    throw new Error("Clinic group not found");
+  }
+
+  // Process logo if it's a data URL
+  let updatedData = { ...data };
+
+  if (
+    data.logo &&
+    typeof data.logo === "string" &&
+    data.logo.startsWith("data:")
+  ) {
+    console.log("[CLINIC_GROUP] Processing logo for update");
+    try {
+      const logoUrl = await uploadPhoto(
+        data.logo,
+        "clinic-groups",
+        groupId,
+        "logo",
+        app
+      );
+      console.log("[CLINIC_GROUP] Logo processed for update", { logoUrl });
+
+      // Replace the data URL with the uploaded URL
+      updatedData.logo = logoUrl;
+    } catch (error) {
+      console.error("[CLINIC_GROUP] Error processing logo for update:", error);
+      // Continue with update even if logo upload fails
+    }
+  }
+
+  // Add timestamp
+  updatedData = {
+    ...updatedData,
+    updatedAt: Timestamp.now(),
+  };
+
+  console.log("[CLINIC_GROUP] Updating clinic group in Firestore");
+  await updateDoc(doc(db, CLINIC_GROUPS_COLLECTION, groupId), updatedData);
+  console.log("[CLINIC_GROUP] Clinic group updated successfully");
+
+  // Return updated data
+  const updatedGroup = await getClinicGroup(db, groupId);
+  if (!updatedGroup) {
+    console.error("[CLINIC_GROUP] Failed to retrieve updated clinic group");
+    throw new Error("Failed to retrieve updated clinic group");
+  }
+
+  return updatedGroup;
+}
+
+/**
+ * Adds an admin to a clinic group
+ * @param db - Firestore database instance
+ * @param groupId - ID of the clinic group
+ * @param adminId - ID of the admin to add (this is the admin document ID, not the user UID)
+ * @param app - Firebase app instance
+ */
+export async function addAdminToGroup(
+  db: Firestore,
+  groupId: string,
+  adminId: string,
+  app: FirebaseApp
+): Promise<void> {
+  console.log("[CLINIC_GROUP] Adding admin to group", { groupId, adminId });
+
+  try {
+    const group = await getClinicGroup(db, groupId);
+    if (!group) {
+      console.error("[CLINIC_GROUP] Clinic group not found", { groupId });
+      throw new Error("Clinic group not found");
+    }
+
+    if (group.admins.includes(adminId)) {
+      console.log("[CLINIC_GROUP] Admin is already in the group", {
+        adminId,
+        groupId,
+      });
+      return; // Admin is already in the group
+    }
+
+    console.log("[CLINIC_GROUP] Updating group with new admin");
+    await updateClinicGroup(
+      db,
+      groupId,
+      {
+        admins: [...group.admins, adminId],
+      },
+      app
+    );
+    console.log("[CLINIC_GROUP] Admin added to group successfully");
+  } catch (error) {
+    console.error("[CLINIC_GROUP] Error adding admin to group:", error);
+    throw error;
+  }
+}
+
+/**
+ * Removes an admin from a clinic group
+ * @param db - Firestore database instance
+ * @param groupId - ID of the clinic group
+ * @param adminId - ID of the admin to remove
+ * @param app - Firebase app instance
+ */
+export async function removeAdminFromGroup(
+  db: Firestore,
+  groupId: string,
+  adminId: string,
+  app: FirebaseApp
+): Promise<void> {
+  const group = await getClinicGroup(db, groupId);
+  if (!group) {
+    throw new Error("Clinic group not found");
+  }
+
+  if (group.ownerId === adminId) {
+    throw new Error("Cannot remove the owner from the group");
+  }
+
+  if (!group.admins.includes(adminId)) {
+    return; // Admin is not in the group
+  }
+
+  await updateClinicGroup(
+    db,
+    groupId,
+    {
+      admins: group.admins.filter((id) => id !== adminId),
+    },
+    app
+  );
+}
+
+/**
+ * Deactivates a clinic group
+ * @param db - Firestore database instance
+ * @param groupId - ID of the clinic group
+ * @param app - Firebase app instance
+ */
+export async function deactivateClinicGroup(
+  db: Firestore,
+  groupId: string,
+  app: FirebaseApp
+): Promise<void> {
+  const group = await getClinicGroup(db, groupId);
+  if (!group) {
+    throw new Error("Clinic group not found");
+  }
+
+  await updateClinicGroup(
+    db,
+    groupId,
+    {
+      isActive: false,
+    },
+    app
+  );
+}
+
+/**
+ * Creates an admin token for a clinic group
+ * @param db - Firestore database instance
+ * @param groupId - ID of the clinic group
+ * @param creatorAdminId - ID of the admin creating the token
+ * @param app - Firebase app instance
+ * @param data - Token data
+ * @returns The created admin token
+ */
+export async function createAdminToken(
+  db: Firestore,
+  groupId: string,
+  creatorAdminId: string,
+  app: FirebaseApp,
+  data?: CreateAdminTokenData
+): Promise<AdminToken> {
+  const group = await getClinicGroup(db, groupId);
+  if (!group) {
+    throw new Error("Clinic group not found");
+  }
+
+  // Proveravamo da li admin pripada grupi
+  if (!group.admins.includes(creatorAdminId)) {
+    throw new Error("Admin does not belong to this clinic group");
+  }
+
+  const now = Timestamp.now();
+  const expiresInDays = data?.expiresInDays || 7; // Default 7 days
+  const email = data?.email || null;
+  const expiresAt = new Timestamp(
+    now.seconds + expiresInDays * 24 * 60 * 60,
+    now.nanoseconds
+  );
+
+  const token: AdminToken = {
+    id: generateId(),
+    token: generateId(),
+    status: AdminTokenStatus.ACTIVE,
+    email,
+    createdAt: now,
+    expiresAt,
+  };
+
+  // Dodajemo token u grupu
+  // Ovo treba promeniti, staviti admin tokene u sub-kolekciju u klinickoj grupi
+  await updateClinicGroup(
+    db,
+    groupId,
+    {
+      adminTokens: [...group.adminTokens, token],
+    },
+    app
+  );
+
+  return token;
+}
+
+/**
+ * Verifies and uses an admin token
+ * @param db - Firestore database instance
+ * @param groupId - ID of the clinic group
+ * @param token - Token to verify
+ * @param userRef - User reference
+ * @param app - Firebase app instance
+ * @returns Whether the token was successfully used
+ */
+export async function verifyAndUseAdminToken(
+  db: Firestore,
+  groupId: string,
+  token: string,
+  userRef: string,
+  app: FirebaseApp
+): Promise<boolean> {
+  const group = await getClinicGroup(db, groupId);
+  if (!group) {
+    throw new Error("Clinic group not found");
+  }
+
+  const adminToken = group.adminTokens.find((t) => t.token === token);
+  if (!adminToken) {
+    throw new Error("Admin token not found");
+  }
+
+  if (adminToken.status !== AdminTokenStatus.ACTIVE) {
+    throw new Error("Admin token is not active");
+  }
+
+  const now = Timestamp.now();
+  if (adminToken.expiresAt.seconds < now.seconds) {
+    // Token je istekao, ažuriramo status
+    const updatedTokens = group.adminTokens.map((t) =>
+      t.id === adminToken.id ? { ...t, status: AdminTokenStatus.EXPIRED } : t
+    );
+
+    await updateClinicGroup(
+      db,
+      groupId,
+      {
+        adminTokens: updatedTokens,
+      },
+      app
+    );
+
+    throw new Error("Admin token has expired");
+  }
+
+  // Token je validan, ažuriramo status
+  const updatedTokens = group.adminTokens.map((t) =>
+    t.id === adminToken.id
+      ? {
+          ...t,
+          status: AdminTokenStatus.USED,
+          usedByUserRef: userRef,
+        }
+      : t
+  );
+
+  await updateClinicGroup(
+    db,
+    groupId,
+    {
+      adminTokens: updatedTokens,
+    },
+    app
+  );
+
+  return true;
+}
+
+/**
+ * Deletes an admin token
+ * @param db - Firestore database instance
+ * @param groupId - ID of the clinic group
+ * @param tokenId - ID of the token to delete
+ * @param adminId - ID of the admin making the deletion
+ * @param app - Firebase app instance
+ */
+export async function deleteAdminToken(
+  db: Firestore,
+  groupId: string,
+  tokenId: string,
+  adminId: string,
+  app: FirebaseApp
+): Promise<void> {
+  const group = await getClinicGroup(db, groupId);
+  if (!group) {
+    throw new Error("Clinic group not found");
+  }
+
+  // Proveravamo da li admin pripada grupi
+  if (!group.admins.includes(adminId)) {
+    throw new Error("Admin does not belong to this clinic group");
+  }
+
+  // Uklanjamo token
+  const updatedTokens = group.adminTokens.filter((t) => t.id !== tokenId);
+
+  await updateClinicGroup(
+    db,
+    groupId,
+    {
+      adminTokens: updatedTokens,
+    },
+    app
+  );
+}
+
+/**
+ * Gets active admin tokens for a clinic group
+ * @param db - Firestore database instance
+ * @param groupId - ID of the clinic group
+ * @param adminId - ID of the admin requesting the tokens
+ * @param app - Firebase app instance (not used but included for consistency)
+ * @returns Array of active admin tokens
+ */
+export async function getActiveAdminTokens(
+  db: Firestore,
+  groupId: string,
+  adminId: string,
+  app: FirebaseApp
+): Promise<AdminToken[]> {
+  const group = await getClinicGroup(db, groupId);
+  if (!group) {
+    throw new Error("Clinic group not found");
+  }
+
+  // Proveravamo da li admin pripada grupi
+  if (!group.admins.includes(adminId)) {
+    throw new Error("Admin does not belong to this clinic group");
+  }
+
+  // Vraćamo samo aktivne tokene
+  return group.adminTokens.filter((t) => t.status === AdminTokenStatus.ACTIVE);
+}