@blackcode_sa/metaestetics-api 1.4.7 → 1.4.9

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

@@ -12,6 +12,7 @@ import {
   Firestore,
   serverTimestamp,
 } from "firebase/firestore";
+import { getStorage, ref, uploadBytes, getDownloadURL } from "firebase/storage";
 import {
   ClinicGroup,
   CreateClinicGroupData,
@@ -19,6 +20,7 @@ import {
   AdminToken,
   AdminTokenStatus,
   CreateAdminTokenData,
+  SubscriptionModel,
 } from "../../../types/clinic";
 import { geohashForLocation } from "geofire-common";
 import {
@@ -26,6 +28,8 @@ import {
   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
@@ -50,6 +54,7 @@ function generateId(): string {
  * @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(
@@ -57,7 +62,8 @@ export async function createClinicGroup(
   data: CreateClinicGroupData,
   ownerId: string,
   isDefault: boolean = false,
-  clinicAdminService: any
+  clinicAdminService: any,
+  app: FirebaseApp
 ): Promise<ClinicGroup> {
   console.log("[CLINIC_GROUP] Starting clinic group creation", {
     ownerId,
@@ -79,14 +85,24 @@ export async function createClinicGroup(
   // Proveravamo da li owner postoji i da li je clinic admin
   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");
+    // 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");
     }
-    console.log("[CLINIC_GROUP] Owner verified as clinic admin");
   } catch (ownerError) {
     console.error("[CLINIC_GROUP] Error verifying owner:", ownerError);
     throw ownerError;
@@ -112,22 +128,43 @@ export async function createClinicGroup(
   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: doc(collection(db, CLINIC_GROUPS_COLLECTION)).id,
+    id: groupId,
+    name: validatedData.name,
+    logo: logoUrl, // Use the uploaded logo URL or the original value
     description: isDefault ? undefined : validatedData.description || undefined,
     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 || undefined,
     },
     contactInfo: {
-      ...validatedData.contactInfo,
+      email: validatedData.contactInfo.email || "",
+      phoneNumber: validatedData.contactInfo.phoneNumber || "",
       alternativePhoneNumber: isDefault
         ? undefined
         : validatedData.contactInfo.alternativePhoneNumber || undefined,
@@ -135,6 +172,15 @@ export async function createClinicGroup(
         ? undefined
         : validatedData.contactInfo.website || undefined,
     },
+    contactPerson: {
+      firstName: validatedData.contactPerson?.firstName || "",
+      lastName: validatedData.contactPerson?.lastName || "",
+      email: validatedData.contactPerson?.email || "",
+      title: validatedData.contactPerson?.title || null,
+      phoneNumber: validatedData.contactPerson?.phoneNumber || null,
+    },
+    subscriptionModel:
+      validatedData.subscriptionModel || SubscriptionModel.NO_SUBSCRIPTION,
     clinics: [],
     clinicsInfo: [],
     admins: [ownerId],
@@ -256,29 +302,64 @@ export async function getAllActiveGroups(
  * @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>
+  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");
   }
 
-  // Ažuriramo podatke
-  const updatedData = {
-    ...data,
+  // 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");
 
-  // Vraćamo ažurirane podatke
+  // 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");
   }
 
@@ -289,25 +370,46 @@ export async function updateClinicGroup(
  * 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
+ * @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
+  adminId: string,
+  app: FirebaseApp
 ): Promise<void> {
-  const group = await getClinicGroup(db, groupId);
-  if (!group) {
-    throw new Error("Clinic group not found");
-  }
+  console.log("[CLINIC_GROUP] Adding admin to group", { groupId, adminId });
 
-  if (group.admins.includes(adminId)) {
-    return; // Admin is already in the group
-  }
+  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");
+    }
 
-  await updateClinicGroup(db, groupId, {
-    admins: [...group.admins, adminId],
-  });
+    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;
+  }
 }
 
 /**
@@ -315,11 +417,13 @@ export async function addAdminToGroup(
  * @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
+  adminId: string,
+  app: FirebaseApp
 ): Promise<void> {
   const group = await getClinicGroup(db, groupId);
   if (!group) {
@@ -334,29 +438,40 @@ export async function removeAdminFromGroup(
     return; // Admin is not in the group
   }
 
-  await updateClinicGroup(db, groupId, {
-    admins: group.admins.filter((id) => id !== adminId),
-  });
+  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
+  groupId: string,
+  app: FirebaseApp
 ): Promise<void> {
   const group = await getClinicGroup(db, groupId);
   if (!group) {
     throw new Error("Clinic group not found");
   }
 
-  await updateDoc(doc(db, CLINIC_GROUPS_COLLECTION, groupId), {
-    isActive: false,
-    updatedAt: Timestamp.now(),
-  });
+  await updateClinicGroup(
+    db,
+    groupId,
+    {
+      isActive: false,
+    },
+    app
+  );
 }
 
 /**
@@ -364,6 +479,7 @@ export async function deactivateClinicGroup(
  * @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
  */
@@ -371,6 +487,7 @@ export async function createAdminToken(
   db: Firestore,
   groupId: string,
   creatorAdminId: string,
+  app: FirebaseApp,
   data?: CreateAdminTokenData
 ): Promise<AdminToken> {
   const group = await getClinicGroup(db, groupId);
@@ -399,9 +516,14 @@ export async function createAdminToken(
   };
 
   // Dodajemo token u grupu
-  await updateClinicGroup(db, groupId, {
-    adminTokens: [...group.adminTokens, token],
-  });
+  await updateClinicGroup(
+    db,
+    groupId,
+    {
+      adminTokens: [...group.adminTokens, token],
+    },
+    app
+  );
 
   return token;
 }
@@ -412,13 +534,15 @@ export async function createAdminToken(
  * @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
+  userRef: string,
+  app: FirebaseApp
 ): Promise<boolean> {
   const group = await getClinicGroup(db, groupId);
   if (!group) {
@@ -441,9 +565,14 @@ export async function verifyAndUseAdminToken(
       t.id === adminToken.id ? { ...t, status: AdminTokenStatus.EXPIRED } : t
     );
 
-    await updateClinicGroup(db, groupId, {
-      adminTokens: updatedTokens,
-    });
+    await updateClinicGroup(
+      db,
+      groupId,
+      {
+        adminTokens: updatedTokens,
+      },
+      app
+    );
 
     throw new Error("Admin token has expired");
   }
@@ -459,9 +588,14 @@ export async function verifyAndUseAdminToken(
       : t
   );
 
-  await updateClinicGroup(db, groupId, {
-    adminTokens: updatedTokens,
-  });
+  await updateClinicGroup(
+    db,
+    groupId,
+    {
+      adminTokens: updatedTokens,
+    },
+    app
+  );
 
   return true;
 }
@@ -472,12 +606,14 @@ export async function verifyAndUseAdminToken(
  * @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
+  adminId: string,
+  app: FirebaseApp
 ): Promise<void> {
   const group = await getClinicGroup(db, groupId);
   if (!group) {
@@ -492,9 +628,14 @@ export async function deleteAdminToken(
   // Uklanjamo token
   const updatedTokens = group.adminTokens.filter((t) => t.id !== tokenId);
 
-  await updateClinicGroup(db, groupId, {
-    adminTokens: updatedTokens,
-  });
+  await updateClinicGroup(
+    db,
+    groupId,
+    {
+      adminTokens: updatedTokens,
+    },
+    app
+  );
 }
 
 /**
@@ -502,12 +643,14 @@ export async function deleteAdminToken(
  * @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
+  adminId: string,
+  app: FirebaseApp
 ): Promise<AdminToken[]> {
   const group = await getClinicGroup(db, groupId);
   if (!group) {