@blackcode_sa/metaestetics-api 1.4.7 → 1.4.9

package/dist/index.mjs

@@ -2375,7 +2375,7 @@ var clinicGroupSchema = z9.object({
   admins: z9.array(z9.string()),
   adminsInfo: z9.array(adminInfoSchema),
   adminTokens: z9.array(adminTokenSchema),
-  ownerId: z9.string(),
+  ownerId: z9.string().nullable(),
   createdAt: z9.instanceof(Date).or(z9.instanceof(Timestamp5)),
   // Timestamp
   updatedAt: z9.instanceof(Date).or(z9.instanceof(Timestamp5)),
@@ -2451,7 +2451,7 @@ var createClinicGroupSchema = z9.object({
   hqLocation: clinicLocationSchema,
   contactInfo: clinicContactInfoSchema,
   contactPerson: contactPersonSchema,
-  ownerId: z9.string(),
+  ownerId: z9.string().nullable(),
   isActive: z9.boolean(),
   logo: z9.string().optional().nullable(),
   practiceType: z9.nativeEnum(PracticeType).optional(),
@@ -2485,7 +2485,7 @@ var createClinicSchema = z9.object({
 });
 var createDefaultClinicGroupSchema = z9.object({
   name: z9.string(),
-  ownerId: z9.string(),
+  ownerId: z9.string().nullable(),
   contactPerson: contactPersonSchema,
   contactInfo: clinicContactInfoSchema,
   hqLocation: clinicLocationSchema,
@@ -2583,45 +2583,7 @@ async function createClinicAdmin(db, data, clinicGroupService) {
     hasGroupId: !!clinicGroupId
   });
   if (validatedData.isGroupOwner && !clinicGroupId) {
-    console.log("[CLINIC_ADMIN] Creating default group for owner");
-    const defaultGroup = {
-      name: `${validatedData.contactInfo.firstName}'s Group`,
-      ownerId: validatedData.userRef,
-      contactPerson: validatedData.contactInfo,
-      contactInfo: {
-        email: validatedData.contactInfo.email,
-        phoneNumber: validatedData.contactInfo.phoneNumber || ""
-      },
-      hqLocation: {
-        address: "",
-        city: "",
-        country: "",
-        postalCode: "",
-        latitude: 0,
-        longitude: 0
-      },
-      isActive: true
-    };
-    console.log("[CLINIC_ADMIN] Default group data prepared", {
-      groupName: defaultGroup.name
-    });
-    try {
-      const clinicGroup = await clinicGroupService.createClinicGroup(
-        defaultGroup,
-        validatedData.userRef,
-        true
-      );
-      clinicGroupId = clinicGroup.id;
-      console.log("[CLINIC_ADMIN] Default group created successfully", {
-        groupId: clinicGroupId
-      });
-    } catch (groupCreationError) {
-      console.error(
-        "[CLINIC_ADMIN] Error creating default group:",
-        groupCreationError
-      );
-      throw groupCreationError;
-    }
+    console.log("[CLINIC_ADMIN] Owner will be assigned to group later");
   } 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");
@@ -2651,16 +2613,12 @@ async function createClinicAdmin(db, data, clinicGroupService) {
     }
   }
   console.log("[CLINIC_ADMIN] Preparing admin data object");
-  if (!clinicGroupId) {
-    console.error(
-      "[CLINIC_ADMIN] clinicGroupId is undefined, which should not happen at this point"
-    );
-    throw new Error("clinicGroupId is required but was undefined");
-  }
   const adminData = {
-    id: validatedData.userRef,
+    id: doc4(collection2(db, CLINIC_ADMINS_COLLECTION)).id,
+    // Generate a new ID for the admin document
     userRef: validatedData.userRef,
-    clinicGroupId,
+    clinicGroupId: clinicGroupId || "",
+    // Empty string for now if no group ID
     isGroupOwner: validatedData.isGroupOwner,
     clinicsManaged: [],
     // Uvek krećemo od prazne liste
@@ -3706,6 +3664,65 @@ import {
 } from "firebase/firestore";
 import { geohashForLocation as geohashForLocation2 } from "geofire-common";
 import { z as z13 } from "zod";
+
+// src/services/clinic/utils/photos.utils.ts
+import {
+  getStorage as getStorage2,
+  ref as ref2,
+  uploadBytes as uploadBytes2,
+  getDownloadURL as getDownloadURL2,
+  deleteObject as deleteObject2
+} from "firebase/storage";
+async function uploadPhoto(photo, entityType, entityId, photoType, app, fileName) {
+  if (!photo || typeof photo !== "string" || !photo.startsWith("data:")) {
+    return photo;
+  }
+  try {
+    console.log(
+      `[PHOTO_UTILS] Uploading ${photoType} for ${entityType}/${entityId}`
+    );
+    const storage = getStorage2(app);
+    const storageFileName = fileName || `${photoType}-${Date.now()}`;
+    const storageRef = ref2(
+      storage,
+      `${entityType}/${entityId}/${storageFileName}`
+    );
+    const base64Data = photo.split(",")[1];
+    const contentType = photo.split(";")[0].split(":")[1];
+    const byteCharacters = atob(base64Data);
+    const byteArrays = [];
+    for (let i = 0; i < byteCharacters.length; i++) {
+      byteArrays.push(byteCharacters.charCodeAt(i));
+    }
+    const blob = new Blob([new Uint8Array(byteArrays)], { type: contentType });
+    await uploadBytes2(storageRef, blob, { contentType });
+    const downloadUrl = await getDownloadURL2(storageRef);
+    console.log(`[PHOTO_UTILS] ${photoType} uploaded successfully`, {
+      downloadUrl
+    });
+    return downloadUrl;
+  } catch (error) {
+    console.error(`[PHOTO_UTILS] Error uploading ${photoType}:`, error);
+    return null;
+  }
+}
+async function uploadMultiplePhotos(photos, entityType, entityId, photoType, app) {
+  if (!photos || !Array.isArray(photos) || photos.length === 0) {
+    return [];
+  }
+  const uploadPromises = photos.map(
+    (photo, index) => uploadPhoto(photo, entityType, entityId, `${photoType}-${index}`, app)
+  );
+  try {
+    const results = await Promise.all(uploadPromises);
+    return results.filter((url) => url !== null);
+  } catch (error) {
+    console.error(`[PHOTO_UTILS] Error uploading multiple photos:`, error);
+    return photos.filter((photo) => !photo.startsWith("data:"));
+  }
+}
+
+// src/services/clinic/utils/clinic-group.utils.ts
 function generateId() {
   const chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
   const timestamp = Date.now().toString(36);
@@ -3715,7 +3732,8 @@ function generateId() {
   ).join("");
   return `${randomPart}-${timestamp}`;
 }
-async function createClinicGroup(db, data, ownerId, isDefault = false, clinicAdminService) {
+async function createClinicGroup(db, data, ownerId, isDefault = false, clinicAdminService, app) {
+  var _a, _b, _c, _d, _e;
   console.log("[CLINIC_GROUP] Starting clinic group creation", {
     ownerId,
     isDefault
@@ -3731,14 +3749,23 @@ async function createClinicGroup(db, data, ownerId, isDefault = false, clinicAdm
   const validatedData = createClinicGroupSchema.parse(data);
   try {
     console.log("[CLINIC_GROUP] Checking if owner exists", { ownerId });
-    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");
+    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");
     }
-    console.log("[CLINIC_GROUP] Owner verified as clinic admin");
   } catch (ownerError) {
     console.error("[CLINIC_GROUP] Error verifying owner:", ownerError);
     throw ownerError;
@@ -3760,23 +3787,49 @@ async function createClinicGroup(db, data, ownerId, isDefault = false, clinicAdm
   }
   const now = Timestamp10.now();
   console.log("[CLINIC_GROUP] Preparing clinic group data object");
+  const groupId = doc7(collection5(db, CLINIC_GROUPS_COLLECTION)).id;
   console.log("[CLINIC_GROUP] Logo value:", {
     logoValue: validatedData.logo,
     logoType: validatedData.logo === null ? "null" : typeof validatedData.logo
   });
+  let logoUrl = await uploadPhoto(
+    validatedData.logo || null,
+    "clinic-groups",
+    groupId,
+    "logo",
+    app
+  );
+  console.log("[CLINIC_GROUP] Logo processed", { logoUrl });
   const groupData = {
     ...validatedData,
-    id: doc7(collection5(db, CLINIC_GROUPS_COLLECTION)).id,
+    id: groupId,
+    name: validatedData.name,
+    logo: logoUrl,
+    // Use the uploaded logo URL or the original value
     description: isDefault ? void 0 : validatedData.description || void 0,
     hqLocation: {
-      ...validatedData.hqLocation,
+      address: validatedData.hqLocation.address || "",
+      city: validatedData.hqLocation.city || "",
+      country: validatedData.hqLocation.country || "",
+      postalCode: validatedData.hqLocation.postalCode || "",
+      latitude: validatedData.hqLocation.latitude || 0,
+      longitude: validatedData.hqLocation.longitude || 0,
       geohash: validatedData.hqLocation.geohash || void 0
     },
     contactInfo: {
-      ...validatedData.contactInfo,
+      email: validatedData.contactInfo.email || "",
+      phoneNumber: validatedData.contactInfo.phoneNumber || "",
       alternativePhoneNumber: isDefault ? void 0 : validatedData.contactInfo.alternativePhoneNumber || void 0,
       website: isDefault ? void 0 : validatedData.contactInfo.website || void 0
     },
+    contactPerson: {
+      firstName: ((_a = validatedData.contactPerson) == null ? void 0 : _a.firstName) || "",
+      lastName: ((_b = validatedData.contactPerson) == null ? void 0 : _b.lastName) || "",
+      email: ((_c = validatedData.contactPerson) == null ? void 0 : _c.email) || "",
+      title: ((_d = validatedData.contactPerson) == null ? void 0 : _d.title) || null,
+      phoneNumber: ((_e = validatedData.contactPerson) == null ? void 0 : _e.phoneNumber) || null
+    },
+    subscriptionModel: validatedData.subscriptionModel || "no_subscription" /* NO_SUBSCRIPTION */,
     clinics: [],
     clinicsInfo: [],
     admins: [ownerId],
@@ -3864,35 +3917,75 @@ async function getAllActiveGroups(db) {
   const querySnapshot = await getDocs5(q);
   return querySnapshot.docs.map((doc14) => doc14.data());
 }
-async function updateClinicGroup(db, groupId, data) {
+async function updateClinicGroup(db, groupId, data, app) {
+  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");
   }
-  const updatedData = {
-    ...data,
+  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 });
+      updatedData.logo = logoUrl;
+    } catch (error) {
+      console.error("[CLINIC_GROUP] Error processing logo for update:", error);
+    }
+  }
+  updatedData = {
+    ...updatedData,
     updatedAt: Timestamp10.now()
   };
+  console.log("[CLINIC_GROUP] Updating clinic group in Firestore");
   await updateDoc10(doc7(db, CLINIC_GROUPS_COLLECTION, groupId), updatedData);
+  console.log("[CLINIC_GROUP] Clinic group updated successfully");
   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;
 }
-async function addAdminToGroup(db, groupId, adminId) {
-  const group = await getClinicGroup(db, groupId);
-  if (!group) {
-    throw new Error("Clinic group not found");
-  }
-  if (group.admins.includes(adminId)) {
-    return;
+async function addAdminToGroup(db, groupId, adminId, app) {
+  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;
+    }
+    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;
   }
-  await updateClinicGroup(db, groupId, {
-    admins: [...group.admins, adminId]
-  });
 }
-async function removeAdminFromGroup(db, groupId, adminId) {
+async function removeAdminFromGroup(db, groupId, adminId, app) {
   const group = await getClinicGroup(db, groupId);
   if (!group) {
     throw new Error("Clinic group not found");
@@ -3903,21 +3996,30 @@ async function removeAdminFromGroup(db, groupId, adminId) {
   if (!group.admins.includes(adminId)) {
     return;
   }
-  await updateClinicGroup(db, groupId, {
-    admins: group.admins.filter((id) => id !== adminId)
-  });
+  await updateClinicGroup(
+    db,
+    groupId,
+    {
+      admins: group.admins.filter((id) => id !== adminId)
+    },
+    app
+  );
 }
-async function deactivateClinicGroup(db, groupId) {
+async function deactivateClinicGroup(db, groupId, app) {
   const group = await getClinicGroup(db, groupId);
   if (!group) {
     throw new Error("Clinic group not found");
   }
-  await updateDoc10(doc7(db, CLINIC_GROUPS_COLLECTION, groupId), {
-    isActive: false,
-    updatedAt: Timestamp10.now()
-  });
+  await updateClinicGroup(
+    db,
+    groupId,
+    {
+      isActive: false
+    },
+    app
+  );
 }
-async function createAdminToken(db, groupId, creatorAdminId, data) {
+async function createAdminToken(db, groupId, creatorAdminId, app, data) {
   const group = await getClinicGroup(db, groupId);
   if (!group) {
     throw new Error("Clinic group not found");
@@ -3938,12 +4040,17 @@ async function createAdminToken(db, groupId, creatorAdminId, data) {
     createdAt: now,
     expiresAt
   };
-  await updateClinicGroup(db, groupId, {
-    adminTokens: [...group.adminTokens, token]
-  });
+  await updateClinicGroup(
+    db,
+    groupId,
+    {
+      adminTokens: [...group.adminTokens, token]
+    },
+    app
+  );
   return token;
 }
-async function verifyAndUseAdminToken(db, groupId, token, userRef) {
+async function verifyAndUseAdminToken(db, groupId, token, userRef, app) {
   const group = await getClinicGroup(db, groupId);
   if (!group) {
     throw new Error("Clinic group not found");
@@ -3960,9 +4067,14 @@ async function verifyAndUseAdminToken(db, groupId, token, userRef) {
     const updatedTokens2 = group.adminTokens.map(
       (t) => t.id === adminToken.id ? { ...t, status: "expired" /* EXPIRED */ } : t
     );
-    await updateClinicGroup(db, groupId, {
-      adminTokens: updatedTokens2
-    });
+    await updateClinicGroup(
+      db,
+      groupId,
+      {
+        adminTokens: updatedTokens2
+      },
+      app
+    );
     throw new Error("Admin token has expired");
   }
   const updatedTokens = group.adminTokens.map(
@@ -3972,12 +4084,17 @@ async function verifyAndUseAdminToken(db, groupId, token, userRef) {
       usedByUserRef: userRef
     } : t
   );
-  await updateClinicGroup(db, groupId, {
-    adminTokens: updatedTokens
-  });
+  await updateClinicGroup(
+    db,
+    groupId,
+    {
+      adminTokens: updatedTokens
+    },
+    app
+  );
   return true;
 }
-async function deleteAdminToken(db, groupId, tokenId, adminId) {
+async function deleteAdminToken(db, groupId, tokenId, adminId, app) {
   const group = await getClinicGroup(db, groupId);
   if (!group) {
     throw new Error("Clinic group not found");
@@ -3986,11 +4103,16 @@ async function deleteAdminToken(db, groupId, tokenId, adminId) {
     throw new Error("Admin does not belong to this clinic group");
   }
   const updatedTokens = group.adminTokens.filter((t) => t.id !== tokenId);
-  await updateClinicGroup(db, groupId, {
-    adminTokens: updatedTokens
-  });
+  await updateClinicGroup(
+    db,
+    groupId,
+    {
+      adminTokens: updatedTokens
+    },
+    app
+  );
 }
-async function getActiveAdminTokens(db, groupId, adminId) {
+async function getActiveAdminTokens(db, groupId, adminId, app) {
   const group = await getClinicGroup(db, groupId);
   if (!group) {
     throw new Error("Clinic group not found");
@@ -4016,7 +4138,8 @@ var ClinicGroupService = class extends BaseService {
       data,
       ownerId,
       isDefault,
-      this.clinicAdminService
+      this.clinicAdminService,
+      this.app
     );
   }
   /**
@@ -4035,25 +4158,35 @@ var ClinicGroupService = class extends BaseService {
    * Ažurira grupaciju klinika
    */
   async updateClinicGroup(groupId, data) {
-    return updateClinicGroup(this.db, groupId, data);
+    return updateClinicGroup(this.db, groupId, data, this.app);
   }
   /**
    * Dodaje admina u grupaciju
    */
   async addAdminToGroup(groupId, adminId) {
-    return addAdminToGroup(this.db, groupId, adminId);
+    return addAdminToGroup(
+      this.db,
+      groupId,
+      adminId,
+      this.app
+    );
   }
   /**
    * Uklanja admina iz grupacije
    */
   async removeAdminFromGroup(groupId, adminId) {
-    return removeAdminFromGroup(this.db, groupId, adminId);
+    return removeAdminFromGroup(
+      this.db,
+      groupId,
+      adminId,
+      this.app
+    );
   }
   /**
    * Deaktivira grupaciju klinika
    */
   async deactivateClinicGroup(groupId) {
-    return deactivateClinicGroup(this.db, groupId);
+    return deactivateClinicGroup(this.db, groupId, this.app);
   }
   /**
    * Sets up additional clinic group information after initial creation
@@ -4063,18 +4196,45 @@ var ClinicGroupService = class extends BaseService {
    * @returns The updated clinic group
    */
   async setupClinicGroup(groupId, setupData) {
+    console.log("[CLINIC_GROUP] Setting up clinic group", { groupId });
     const clinicGroup = await this.getClinicGroup(groupId);
     if (!clinicGroup) {
+      console.error("[CLINIC_GROUP] Clinic group not found", { groupId });
       throw new Error(`Clinic group with ID ${groupId} not found`);
     }
+    let logoUrl = setupData.logo;
+    if (logoUrl && typeof logoUrl === "string" && logoUrl.startsWith("data:")) {
+      console.log("[CLINIC_GROUP] Processing logo in setupClinicGroup");
+      try {
+        const uploadedLogoUrl = await uploadPhoto(
+          logoUrl,
+          "clinic-groups",
+          groupId,
+          "logo",
+          this.app
+        );
+        console.log("[CLINIC_GROUP] Logo processed in setupClinicGroup", {
+          uploadedLogoUrl
+        });
+        if (uploadedLogoUrl !== null) {
+          logoUrl = uploadedLogoUrl;
+        }
+      } catch (error) {
+        console.error(
+          "[CLINIC_GROUP] Error processing logo in setupClinicGroup:",
+          error
+        );
+      }
+    }
     const updateData = {
       languages: setupData.languages,
       practiceType: setupData.practiceType,
       description: setupData.description,
-      logo: setupData.logo,
+      logo: logoUrl,
       calendarSyncEnabled: setupData.calendarSyncEnabled,
       autoConfirmAppointments: setupData.autoConfirmAppointments
     };
+    console.log("[CLINIC_GROUP] Updating clinic group with setup data");
     return this.updateClinicGroup(groupId, updateData);
   }
   /**
@@ -4085,6 +4245,7 @@ var ClinicGroupService = class extends BaseService {
       this.db,
       groupId,
       creatorAdminId,
+      this.app,
       data
     );
   }
@@ -4096,7 +4257,8 @@ var ClinicGroupService = class extends BaseService {
       this.db,
       groupId,
       token,
-      userRef
+      userRef,
+      this.app
     );
   }
   /**
@@ -4107,14 +4269,20 @@ var ClinicGroupService = class extends BaseService {
       this.db,
       groupId,
       tokenId,
-      adminId
+      adminId,
+      this.app
     );
   }
   /**
    * Dohvata aktivne admin tokene
    */
   async getActiveAdminTokens(groupId, adminId) {
-    return getActiveAdminTokens(this.db, groupId, adminId);
+    return getActiveAdminTokens(
+      this.db,
+      groupId,
+      adminId,
+      this.app
+    );
   }
 };
 
@@ -4132,44 +4300,193 @@ import {
 } from "firebase/firestore";
 import { geohashForLocation as geohashForLocation3 } from "geofire-common";
 import { z as z14 } from "zod";
-async function createClinic(db, data, creatorAdminId, clinicGroupService, clinicAdminService) {
-  const validatedData = createClinicSchema.parse(data);
-  const admin = await clinicAdminService.getClinicAdmin(creatorAdminId);
-  if (!admin) {
-    throw new Error("Admin not found");
+async function createClinic(db, data, creatorAdminId, clinicGroupService, clinicAdminService, app) {
+  var _a;
+  console.log("[CLINIC] Starting clinic creation", { creatorAdminId });
+  console.log("[CLINIC] Input data:", JSON.stringify(data, null, 2));
+  try {
+    const validatedData2 = createClinicSchema.parse(data);
+    console.log("[CLINIC] Data validation passed");
+  } catch (validationError) {
+    console.error("[CLINIC] Data validation failed:", validationError);
+    throw validationError;
   }
-  if (admin.clinicGroupId !== validatedData.clinicGroupId) {
-    throw new Error("Admin does not belong to this clinic group");
+  const validatedData = createClinicSchema.parse(data);
+  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;
   }
-  const group = await clinicGroupService.getClinicGroup(
-    validatedData.clinicGroupId
-  );
-  if (!group) {
-    throw new Error("Clinic group not found");
+  try {
+    console.log("[CLINIC] Checking if clinic group exists");
+    const group = await clinicGroupService.getClinicGroup(
+      validatedData.clinicGroupId
+    );
+    if (!group) {
+      console.error("[CLINIC] Clinic group not found", {
+        groupId: validatedData.clinicGroupId
+      });
+      throw new Error("Clinic group not found");
+    }
+    console.log("[CLINIC] Clinic group verified");
+  } catch (groupError) {
+    console.error("[CLINIC] Error verifying clinic group:", groupError);
+    throw groupError;
   }
+  console.log("[CLINIC] Generating geohash for location");
   if (validatedData.location) {
-    validatedData.location.geohash = geohashForLocation3([
-      validatedData.location.latitude,
-      validatedData.location.longitude
-    ]);
+    try {
+      validatedData.location.geohash = geohashForLocation3([
+        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;
+    }
+  }
+  const clinicId = doc8(collection6(db, CLINICS_COLLECTION)).id;
+  console.log("[CLINIC] Generated clinic ID:", clinicId);
+  console.log("[CLINIC] Processing photos");
+  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);
+    }
+  }
+  let processedPhotos = [];
+  if (validatedData.photos && validatedData.photos.length > 0) {
+    console.log("[CLINIC] Processing regular photos");
+    try {
+      processedPhotos = await uploadMultiplePhotos(
+        validatedData.photos,
+        "clinics",
+        clinicId,
+        "photo",
+        app
+      );
+      console.log("[CLINIC] Regular photos processed", {
+        count: processedPhotos.length
+      });
+    } catch (photosError) {
+      console.error("[CLINIC] Error processing regular photos:", photosError);
+      processedPhotos = validatedData.photos.filter(
+        (photo) => !photo.startsWith("data:")
+      );
+    }
+  }
+  let processedFeaturedPhotos = [];
+  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
+      );
+      processedFeaturedPhotos = validatedData.featuredPhotos.filter(
+        (photo) => !photo.startsWith("data:")
+      );
+    }
+  }
+  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);
+      processedPhotosWithTags = ((_a = validatedData.photosWithTags) == null ? void 0 : _a.filter(
+        (photo) => !photo.url.startsWith("data:")
+      )) || [];
+    }
   }
   const now = Timestamp11.now();
+  console.log("[CLINIC] Preparing clinic data object");
   const clinicData = {
     ...validatedData,
-    id: doc8(collection6(db, CLINICS_COLLECTION)).id,
+    id: clinicId,
     description: validatedData.description || void 0,
     location: {
-      ...validatedData.location,
+      address: validatedData.location.address || "",
+      city: validatedData.location.city || "",
+      country: validatedData.location.country || "",
+      postalCode: validatedData.location.postalCode || "",
+      latitude: validatedData.location.latitude || 0,
+      longitude: validatedData.location.longitude || 0,
       geohash: validatedData.location.geohash || void 0
     },
     contactInfo: {
-      ...validatedData.contactInfo,
+      email: validatedData.contactInfo.email || "",
+      phoneNumber: validatedData.contactInfo.phoneNumber || "",
       alternativePhoneNumber: validatedData.contactInfo.alternativePhoneNumber || void 0,
       website: validatedData.contactInfo.website || void 0
     },
+    logo: logoUrl || void 0,
     tags: validatedData.tags || [],
-    featuredPhotos: [],
-    photos: validatedData.photos || [],
+    featuredPhotos: processedFeaturedPhotos || [],
+    photos: processedPhotos || [],
+    photosWithTags: processedPhotosWithTags,
     doctors: [],
     doctorsInfo: [],
     services: [],
@@ -4184,17 +4501,73 @@ async function createClinic(db, data, creatorAdminId, clinicGroupService, clinic
     isVerified: false
   };
   try {
-    clinicSchema.parse(clinicData);
-    await setDoc10(doc8(db, CLINICS_COLLECTION, clinicData.id), clinicData);
-    await clinicGroupService.updateClinicGroup(validatedData.clinicGroupId, {
-      clinics: [...group.clinics, clinicData.id]
+    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;
+    }
+    console.log("[CLINIC] Saving clinic to Firestore", {
+      clinicId: clinicData.id
+    });
+    try {
+      await setDoc10(doc8(db, CLINICS_COLLECTION, clinicData.id), clinicData);
+      console.log("[CLINIC] Clinic saved successfully");
+    } catch (firestoreError) {
+      console.error("[CLINIC] Error saving to Firestore:", firestoreError);
+      throw firestoreError;
+    }
+    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);
+    }
+    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
+      );
+    }
+    console.log("[CLINIC] Clinic creation completed successfully", {
+      clinicId: clinicData.id,
+      clinicName: clinicData.name
     });
-    await clinicAdminService.addClinicToManaged(creatorAdminId, clinicData.id);
     return clinicData;
   } catch (error) {
     if (error instanceof z14.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;
   }
 }
@@ -4215,27 +4588,177 @@ async function getClinicsByGroup(db, groupId) {
   const querySnapshot = await getDocs6(q);
   return querySnapshot.docs.map((doc14) => doc14.data());
 }
-async function updateClinic(db, clinicId, data, adminId, clinicAdminService) {
+async function updateClinic(db, clinicId, data, adminId, clinicAdminService, app) {
+  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");
   }
-  const admin = await clinicAdminService.getClinicAdmin(adminId);
-  if (!admin) {
-    throw new Error("Admin not found");
+  try {
+    console.log("[CLINIC] Checking admin permissions");
+    const admin = await clinicAdminService.getClinicAdmin(adminId);
+    if (!admin) {
+      console.error("[CLINIC] Admin not found", { adminId });
+      throw new Error("Admin not found");
+    }
+    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;
+  }
+  let updatedData = { ...data };
+  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);
+    }
   }
-  if (!admin.isGroupOwner && !admin.clinicsManaged.includes(clinicId)) {
-    throw new Error("Admin does not have permission to update this clinic");
+  if (data.photos && data.photos.length > 0) {
+    console.log("[CLINIC] Processing regular photos update");
+    try {
+      const dataUrlPhotos = data.photos.filter(
+        (photo) => typeof photo === "string" && photo.startsWith("data:")
+      );
+      const existingPhotos = data.photos.filter(
+        (photo) => typeof photo === "string" && !photo.startsWith("data:")
+      );
+      if (dataUrlPhotos.length > 0) {
+        const uploadedPhotos = await uploadMultiplePhotos(
+          dataUrlPhotos,
+          "clinics",
+          clinicId,
+          "photo",
+          app
+        );
+        console.log("[CLINIC] Regular photos update processed", {
+          count: uploadedPhotos.length
+        });
+        updatedData.photos = [...existingPhotos, ...uploadedPhotos];
+      }
+    } catch (photosError) {
+      console.error(
+        "[CLINIC] Error processing regular photos update:",
+        photosError
+      );
+      updatedData.photos = data.photos.filter(
+        (photo) => typeof photo === "string" && !photo.startsWith("data:")
+      );
+    }
   }
-  const updatedData = {
-    ...data,
+  if (data.featuredPhotos && data.featuredPhotos.length > 0) {
+    console.log("[CLINIC] Processing featured photos update");
+    try {
+      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
+        });
+        updatedData.featuredPhotos = [...existingPhotos, ...uploadedPhotos];
+      }
+    } catch (featuredError) {
+      console.error(
+        "[CLINIC] Error processing featured photos update:",
+        featuredError
+      );
+      updatedData.featuredPhotos = data.featuredPhotos.filter(
+        (photo) => typeof photo === "string" && !photo.startsWith("data:")
+      );
+    }
+  }
+  if (data.photosWithTags && data.photosWithTags.length > 0) {
+    console.log("[CLINIC] Processing photos with tags update");
+    try {
+      const updatedPhotosWithTags = [];
+      for (const photoWithTag of data.photosWithTags) {
+        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);
+        }
+      }
+      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
+      );
+      updatedData.photosWithTags = data.photosWithTags.filter(
+        (photo) => !photo.url.startsWith("data:")
+      );
+    }
+  }
+  updatedData = {
+    ...updatedData,
     updatedAt: Timestamp11.now()
   };
-  await updateDoc11(doc8(db, CLINICS_COLLECTION, clinicId), updatedData);
+  console.log("[CLINIC] Updating clinic in Firestore");
+  try {
+    await updateDoc11(doc8(db, CLINICS_COLLECTION, clinicId), updatedData);
+    console.log("[CLINIC] Clinic updated successfully");
+  } catch (updateError) {
+    console.error("[CLINIC] Error updating clinic in Firestore:", updateError);
+    throw updateError;
+  }
   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;
 }
 async function deactivateClinic(db, clinicId, adminId, clinicAdminService) {
@@ -4247,7 +4770,8 @@ async function deactivateClinic(db, clinicId, adminId, clinicAdminService) {
   if (!admin) {
     throw new Error("Admin not found");
   }
-  if (!admin.isGroupOwner && !admin.clinicsManaged.includes(clinicId)) {
+  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 updateDoc11(doc8(db, CLINICS_COLLECTION, clinicId), {
@@ -4292,27 +4816,28 @@ async function getActiveClinicsByAdmin(db, adminId, clinicAdminService, clinicGr
 import {
   collection as collection7,
   doc as doc9,
-  setDoc as setDoc11,
-  Timestamp as Timestamp12
+  Timestamp as Timestamp12,
+  getDoc as getDoc13,
+  addDoc as addDoc2
 } from "firebase/firestore";
-async function addReview(db, clinicId, review) {
-  const clinic = await getClinic(db, clinicId);
-  if (!clinic) {
+async function addReview(db, clinicId, review, app) {
+  const clinicRef = doc9(db, "clinics", clinicId);
+  const clinicSnap = await getDoc13(clinicRef);
+  if (!clinicSnap.exists()) {
     throw new Error("Clinic not found");
   }
+  const clinic = clinicSnap.data();
   const now = Timestamp12.now();
   const reviewData = {
+    ...review,
     id: doc9(collection7(db, "clinic_reviews")).id,
     clinicId,
-    patientId: review.patientId,
-    rating: review.rating,
-    comment: review.comment,
     createdAt: now,
     updatedAt: now,
     isVerified: false
   };
   clinicReviewSchema.parse(reviewData);
-  await setDoc11(doc9(db, "clinic_reviews", reviewData.id), reviewData);
+  await addDoc2(collection7(db, "clinic_reviews"), reviewData);
   const newRating = clinic.rating ? {
     average: (clinic.rating.average * clinic.rating.count + review.rating) / (clinic.rating.count + 1),
     count: clinic.rating.count + 1
@@ -4328,28 +4853,24 @@ async function addReview(db, clinicId, review) {
         ...clinic.reviewsInfo,
         {
           id: reviewData.id,
-          rating: review.rating,
-          text: review.comment,
-          patientId: review.patientId,
-          patientName: "Patient",
-          // This should be fetched from patient service
-          patientPhoto: "",
-          // This should be fetched from patient service
-          createdAt: now,
-          updatedAt: now
+          patientId: reviewData.patientId,
+          rating: reviewData.rating,
+          comment: reviewData.comment,
+          createdAt: reviewData.createdAt
         }
       ]
     },
-    clinic.admins[0],
-    // Using the first admin for the update
-    { getClinicAdmin: async (id) => ({ isGroupOwner: true }) }
-    // Mock admin service
+    "system",
+    // System update, no admin ID needed
+    null,
+    // No clinic admin service needed for system updates
+    app
   );
   return reviewData;
 }
 
 // src/services/clinic/utils/tag.utils.ts
-async function addTags(db, clinicId, adminId, newTags, clinicAdminService) {
+async function addTags(db, clinicId, adminId, newTags, clinicAdminService, app) {
   const clinic = await getClinic(db, clinicId);
   if (!clinic) {
     throw new Error("Clinic not found");
@@ -4358,7 +4879,8 @@ async function addTags(db, clinicId, adminId, newTags, clinicAdminService) {
   if (!admin) {
     throw new Error("Admin not found");
   }
-  if (!admin.isGroupOwner && !admin.clinicsManaged.includes(clinicId)) {
+  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 update this clinic");
   }
   const updatedTags = [.../* @__PURE__ */ new Set([...clinic.tags, ...newTags.tags || []])];
@@ -4369,10 +4891,11 @@ async function addTags(db, clinicId, adminId, newTags, clinicAdminService) {
       tags: updatedTags
     },
     adminId,
-    clinicAdminService
+    clinicAdminService,
+    app
   );
 }
-async function removeTags(db, clinicId, adminId, tagsToRemove, clinicAdminService) {
+async function removeTags(db, clinicId, adminId, tagsToRemove, clinicAdminService, app) {
   const clinic = await getClinic(db, clinicId);
   if (!clinic) {
     throw new Error("Clinic not found");
@@ -4381,14 +4904,12 @@ async function removeTags(db, clinicId, adminId, tagsToRemove, clinicAdminServic
   if (!admin) {
     throw new Error("Admin not found");
   }
-  if (!admin.isGroupOwner && !admin.clinicsManaged.includes(clinicId)) {
+  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 update this clinic");
   }
   const updatedTags = clinic.tags.filter(
-    (tag) => {
-      var _a;
-      return !((_a = tagsToRemove.tags) == null ? void 0 : _a.includes(tag));
-    }
+    (tag) => !tagsToRemove.tags || !tagsToRemove.tags.includes(tag)
   );
   return updateClinic(
     db,
@@ -4397,7 +4918,8 @@ async function removeTags(db, clinicId, adminId, tagsToRemove, clinicAdminServic
       tags: updatedTags
     },
     adminId,
-    clinicAdminService
+    clinicAdminService,
+    app
   );
 }
 
@@ -4472,7 +4994,8 @@ var ClinicService = class extends BaseService {
       data,
       creatorAdminId,
       this.clinicGroupService,
-      this.clinicAdminService
+      this.clinicAdminService,
+      this.app
     );
   }
   /**
@@ -4507,14 +5030,15 @@ var ClinicService = class extends BaseService {
       clinicId,
       data,
       adminId,
-      this.clinicAdminService
+      this.clinicAdminService,
+      this.app
     );
   }
   /**
    * Dodaje recenziju klinici
    */
   async addReview(clinicId, review) {
-    return addReview(this.db, clinicId, review);
+    return addReview(this.db, clinicId, review, this.app);
   }
   /**
    * Deaktivira kliniku
@@ -4536,7 +5060,8 @@ var ClinicService = class extends BaseService {
       clinicId,
       adminId,
       newTags,
-      this.clinicAdminService
+      this.clinicAdminService,
+      this.app
     );
   }
   /**
@@ -4548,7 +5073,8 @@ var ClinicService = class extends BaseService {
       clinicId,
       adminId,
       tagsToRemove,
-      this.clinicAdminService
+      this.clinicAdminService,
+      this.app
     );
   }
   /**
@@ -4583,12 +5109,21 @@ var ClinicService = class extends BaseService {
    * @returns The created clinic
    */
   async createClinicBranch(clinicGroupId, setupData, adminId) {
+    var _a, _b;
+    console.log("[CLINIC_SERVICE] Starting clinic branch creation", {
+      clinicGroupId,
+      adminId
+    });
     const clinicGroup = await this.clinicGroupService.getClinicGroup(
       clinicGroupId
     );
     if (!clinicGroup) {
+      console.error("[CLINIC_SERVICE] Clinic group not found", {
+        clinicGroupId
+      });
       throw new Error(`Clinic group with ID ${clinicGroupId} not found`);
     }
+    console.log("[CLINIC_SERVICE] Clinic group verified");
     const createClinicData = {
       clinicGroupId,
       name: setupData.name,
@@ -4597,8 +5132,8 @@ var ClinicService = class extends BaseService {
       contactInfo: setupData.contactInfo,
       workingHours: setupData.workingHours,
       tags: setupData.tags,
-      photos: setupData.photos,
-      photosWithTags: setupData.photosWithTags,
+      photos: setupData.photos || [],
+      photosWithTags: setupData.photosWithTags || [],
       doctors: [],
       services: [],
       admins: [adminId],
@@ -4607,7 +5142,17 @@ var ClinicService = class extends BaseService {
       logo: setupData.logo,
       featuredPhotos: setupData.featuredPhotos || []
     };
+    console.log("[CLINIC_SERVICE] Creating clinic branch with data", {
+      name: createClinicData.name,
+      hasLogo: !!createClinicData.logo,
+      photosCount: createClinicData.photos.length,
+      featuredPhotosCount: ((_a = createClinicData.featuredPhotos) == null ? void 0 : _a.length) || 0,
+      photosWithTagsCount: ((_b = createClinicData.photosWithTags) == null ? void 0 : _b.length) || 0
+    });
     const clinic = await this.createClinic(createClinicData, adminId);
+    console.log("[CLINIC_SERVICE] Clinic branch created successfully", {
+      clinicId: clinic.id
+    });
     return clinic;
   }
 };
@@ -4729,12 +5274,38 @@ var AuthService = class extends BaseService {
             "Clinic group data is required when creating a new group"
           );
         }
+        console.log("[AUTH] Creating clinic admin first (without group)");
+        const createClinicAdminData = {
+          userRef: firebaseUser.uid,
+          isGroupOwner: true,
+          clinicsManaged: [],
+          contactInfo: contactPerson,
+          roleTitle: data.title,
+          isActive: true
+          // No clinicGroupId yet
+        };
+        let adminProfile;
+        try {
+          adminProfile = await clinicAdminService.createClinicAdmin(
+            createClinicAdminData
+          );
+          console.log("[AUTH] Clinic admin created successfully", {
+            adminId: adminProfile.id
+          });
+        } catch (adminCreationError) {
+          console.error(
+            "[AUTH] Clinic admin creation failed:",
+            adminCreationError
+          );
+          throw adminCreationError;
+        }
         const createClinicGroupData = {
           name: data.clinicGroupData.name,
           hqLocation: data.clinicGroupData.hqLocation,
           contactInfo: data.clinicGroupData.contactInfo,
           contactPerson,
-          ownerId: firebaseUser.uid,
+          ownerId: adminProfile.id,
+          // Use admin profile ID, not user UID
           isActive: true,
           logo: data.clinicGroupData.logo || null,
           subscriptionModel: data.clinicGroupData.subscriptionModel || "no_subscription" /* NO_SUBSCRIPTION */
@@ -4742,13 +5313,24 @@ var AuthService = class extends BaseService {
         console.log("[AUTH] Clinic group data prepared", {
           groupName: createClinicGroupData.name
         });
+        let clinicGroup;
         try {
-          await clinicGroupService.createClinicGroup(
+          clinicGroup = await clinicGroupService.createClinicGroup(
             createClinicGroupData,
-            firebaseUser.uid,
-            true
+            adminProfile.id,
+            // Use admin profile ID, not user UID
+            false
+            // This is not a default group since we're providing complete data
           );
-          console.log("[AUTH] Clinic group created successfully");
+          console.log("[AUTH] Clinic group created successfully", {
+            groupId: clinicGroup.id
+          });
+          console.log("[AUTH] Updating admin with clinic group ID");
+          await clinicAdminService.updateClinicAdmin(adminProfile.id, {
+            // Use admin profile ID, not user UID
+            clinicGroupId: clinicGroup.id
+          });
+          console.log("[AUTH] Admin updated with clinic group ID successfully");
         } catch (groupCreationError) {
           console.error(
             "[AUTH] Clinic group creation failed:",
@@ -4821,9 +5403,14 @@ var AuthService = class extends BaseService {
           roleTitle: data.title,
           isActive: true
         };
+        let adminProfile;
         try {
-          await clinicAdminService.createClinicAdmin(createClinicAdminData);
-          console.log("[AUTH] Clinic admin created successfully");
+          adminProfile = await clinicAdminService.createClinicAdmin(
+            createClinicAdminData
+          );
+          console.log("[AUTH] Clinic admin created successfully", {
+            adminId: adminProfile.id
+          });
         } catch (adminCreationError) {
           console.error(
             "[AUTH] Clinic admin creation failed:",
@@ -5132,7 +5719,7 @@ var AuthService = class extends BaseService {
 import {
   collection as collection10,
   doc as doc11,
-  getDoc as getDoc14,
+  getDoc as getDoc15,
   getDocs as getDocs9,
   query as query9,
   where as where9,
@@ -5140,8 +5727,8 @@ import {
   deleteDoc as deleteDoc6,
   orderBy,
   Timestamp as Timestamp14,
-  addDoc,
-  writeBatch as writeBatch2
+  addDoc as addDoc3,
+  writeBatch as writeBatch3
 } from "firebase/firestore";
 
 // src/types/notifications/index.ts
@@ -5178,7 +5765,7 @@ var NotificationService = class extends BaseService {
       isRead: false,
       userRole: notification.userRole || "patient" /* PATIENT */
     };
-    const docRef = await addDoc(notificationsRef, notificationData);
+    const docRef = await addDoc3(notificationsRef, notificationData);
     return {
       ...notificationData,
       id: docRef.id
@@ -5193,7 +5780,7 @@ var NotificationService = class extends BaseService {
       NOTIFICATIONS_COLLECTION,
       notificationId
     );
-    const notificationDoc = await getDoc14(notificationRef);
+    const notificationDoc = await getDoc15(notificationRef);
     if (!notificationDoc.exists()) {
       return null;
     }
@@ -5252,7 +5839,7 @@ var NotificationService = class extends BaseService {
    */
   async markAllAsRead(userId) {
     const notifications = await this.getUnreadNotifications(userId);
-    const batch = writeBatch2(this.db);
+    const batch = writeBatch3(this.db);
     notifications.forEach((notification) => {
       const notificationRef = doc11(
         this.db,
@@ -5328,7 +5915,7 @@ var NotificationService = class extends BaseService {
 import {
   collection as collection11,
   doc as doc12,
-  getDoc as getDoc15,
+  getDoc as getDoc16,
   getDocs as getDocs10,
   setDoc as setDoc13,
   updateDoc as updateDoc14,
@@ -5384,7 +5971,7 @@ var DocumentationTemplateService = class extends BaseService {
    */
   async getTemplateById(templateId) {
     const docRef = doc12(this.collectionRef, templateId);
-    const docSnap = await getDoc15(docRef);
+    const docSnap = await getDoc16(docRef);
     if (!docSnap.exists()) {
       return null;
     }
@@ -5523,7 +6110,7 @@ var DocumentationTemplateService = class extends BaseService {
 import {
   collection as collection12,
   doc as doc13,
-  getDoc as getDoc16,
+  getDoc as getDoc17,
   getDocs as getDocs11,
   setDoc as setDoc14,
   updateDoc as updateDoc15,
@@ -5580,7 +6167,7 @@ var FilledDocumentService = class extends BaseService {
    */
   async getFilledDocumentById(documentId) {
     const docRef = doc13(this.collectionRef, documentId);
-    const docSnap = await getDoc16(docRef);
+    const docSnap = await getDoc17(docRef);
     if (!docSnap.exists()) {
       return null;
     }