@blackcode_sa/metaestetics-api 1.4.6 → 1.4.7

package/src/services/auth.service.ts

@@ -108,24 +108,58 @@ export class AuthService extends BaseService {
    */
   async signUpClinicAdmin(data: ClinicAdminSignupData): Promise<User> {
     try {
+      console.log("[AUTH] Starting clinic admin signup process", {
+        email: data.email,
+      });
+
       // Validate data
-      await clinicAdminSignupSchema.parseAsync(data);
+      try {
+        await clinicAdminSignupSchema.parseAsync(data);
+        console.log("[AUTH] Clinic admin signup data validation passed");
+      } catch (validationError) {
+        console.error(
+          "[AUTH] Validation error in signUpClinicAdmin:",
+          validationError
+        );
+        throw validationError;
+      }
 
       // Create Firebase user
-      const { user: firebaseUser } = await createUserWithEmailAndPassword(
-        this.auth,
-        data.email,
-        data.password
-      );
+      console.log("[AUTH] Creating Firebase user");
+      let firebaseUser;
+      try {
+        const result = await createUserWithEmailAndPassword(
+          this.auth,
+          data.email,
+          data.password
+        );
+        firebaseUser = result.user;
+        console.log("[AUTH] Firebase user created successfully", {
+          uid: firebaseUser.uid,
+        });
+      } catch (firebaseError) {
+        console.error("[AUTH] Firebase user creation failed:", firebaseError);
+        throw firebaseError;
+      }
 
       // Create user with CLINIC_ADMIN role
-      const user = await this.userService.createUser(
-        firebaseUser,
-        [UserRole.CLINIC_ADMIN],
-        {
-          skipProfileCreation: true,
-        }
-      );
+      console.log("[AUTH] Creating user with CLINIC_ADMIN role");
+      let user;
+      try {
+        user = await this.userService.createUser(
+          firebaseUser,
+          [UserRole.CLINIC_ADMIN],
+          {
+            skipProfileCreation: true,
+          }
+        );
+        console.log("[AUTH] User with CLINIC_ADMIN role created successfully", {
+          userId: user.uid,
+        });
+      } catch (userCreationError) {
+        console.error("[AUTH] User creation failed:", userCreationError);
+        throw userCreationError;
+      }
 
       // Create contact person object
       const contactPerson: ContactPerson = {
@@ -135,8 +169,10 @@ export class AuthService extends BaseService {
         email: data.email,
         phoneNumber: data.phoneNumber,
       };
+      console.log("[AUTH] Contact person object created");
 
       // Initialize services
+      console.log("[AUTH] Initializing clinic services");
       const clinicAdminService = new ClinicAdminService(
         this.db,
         this.auth,
@@ -158,10 +194,15 @@ export class AuthService extends BaseService {
 
       // Set services to resolve circular dependencies
       clinicAdminService.setServices(clinicGroupService, clinicService);
+      console.log(
+        "[AUTH] Services initialized and circular dependencies resolved"
+      );
 
       if (data.isCreatingNewGroup) {
+        console.log("[AUTH] Creating new clinic group flow");
         // Create new clinic group
         if (!data.clinicGroupData) {
+          console.error("[AUTH] Clinic group data is missing");
           throw new Error(
             "Clinic group data is required when creating a new group"
           );
@@ -180,22 +221,40 @@ export class AuthService extends BaseService {
             data.clinicGroupData.subscriptionModel ||
             SubscriptionModel.NO_SUBSCRIPTION,
         };
+        console.log("[AUTH] Clinic group data prepared", {
+          groupName: createClinicGroupData.name,
+        });
 
         // Create clinic group
-        await clinicGroupService.createClinicGroup(
-          createClinicGroupData,
-          firebaseUser.uid,
-          true
-        );
+        try {
+          await clinicGroupService.createClinicGroup(
+            createClinicGroupData,
+            firebaseUser.uid,
+            true
+          );
+          console.log("[AUTH] Clinic group created successfully");
+        } catch (groupCreationError) {
+          console.error(
+            "[AUTH] Clinic group creation failed:",
+            groupCreationError
+          );
+          throw groupCreationError;
+        }
       } else {
+        console.log("[AUTH] Joining existing clinic group flow");
         // Join existing clinic group with token
         if (!data.inviteToken) {
+          console.error("[AUTH] Invite token is missing");
           throw new Error(
             "Invite token is required when joining an existing group"
           );
         }
+        console.log("[AUTH] Invite token provided", {
+          token: data.inviteToken,
+        });
 
         // Find the token in the database
+        console.log("[AUTH] Searching for token in clinic groups");
         const groupsRef = collection(this.db, CLINIC_GROUPS_COLLECTION);
         const q = query(groupsRef);
         const querySnapshot = await getDocs(q);
@@ -203,29 +262,56 @@ export class AuthService extends BaseService {
         let foundGroup: ClinicGroup | null = null;
         let foundToken: AdminToken | null = null;
 
+        console.log(
+          "[AUTH] Found",
+          querySnapshot.size,
+          "clinic groups to check"
+        );
         for (const docSnapshot of querySnapshot.docs) {
           const group = docSnapshot.data() as ClinicGroup;
+          console.log("[AUTH] Checking group", {
+            groupId: group.id,
+            groupName: group.name,
+          });
 
           // Find the token in the group's tokens
-          const token = group.adminTokens.find(
-            (t) =>
+          const token = group.adminTokens.find((t) => {
+            const isMatch =
               t.token === data.inviteToken &&
               t.status === AdminTokenStatus.ACTIVE &&
-              new Date(t.expiresAt.toDate()) > new Date()
-          );
+              new Date(t.expiresAt.toDate()) > new Date();
+
+            console.log("[AUTH] Checking token", {
+              tokenId: t.id,
+              tokenMatch: t.token === data.inviteToken,
+              tokenStatus: t.status,
+              tokenActive: t.status === AdminTokenStatus.ACTIVE,
+              tokenExpiry: new Date(t.expiresAt.toDate()),
+              tokenExpired: new Date(t.expiresAt.toDate()) <= new Date(),
+              isMatch,
+            });
+
+            return isMatch;
+          });
 
           if (token) {
             foundGroup = group;
             foundToken = token;
+            console.log("[AUTH] Found matching token in group", {
+              groupId: group.id,
+              tokenId: token.id,
+            });
             break;
           }
         }
 
         if (!foundGroup || !foundToken) {
+          console.error("[AUTH] No valid token found in any clinic group");
           throw new Error("Invalid or expired invite token");
         }
 
         // Create clinic admin
+        console.log("[AUTH] Creating clinic admin");
         const createClinicAdminData: CreateClinicAdminData = {
           userRef: firebaseUser.uid,
           clinicGroupId: foundGroup.id,
@@ -236,27 +322,51 @@ export class AuthService extends BaseService {
           isActive: true,
         };
 
-        await clinicAdminService.createClinicAdmin(createClinicAdminData);
+        try {
+          await clinicAdminService.createClinicAdmin(createClinicAdminData);
+          console.log("[AUTH] Clinic admin created successfully");
+        } catch (adminCreationError) {
+          console.error(
+            "[AUTH] Clinic admin creation failed:",
+            adminCreationError
+          );
+          throw adminCreationError;
+        }
 
         // Mark token as used
-        await clinicGroupService.verifyAndUseAdminToken(
-          foundGroup.id,
-          data.inviteToken,
-          firebaseUser.uid
-        );
+        try {
+          await clinicGroupService.verifyAndUseAdminToken(
+            foundGroup.id,
+            data.inviteToken,
+            firebaseUser.uid
+          );
+          console.log("[AUTH] Token marked as used successfully");
+        } catch (tokenUseError) {
+          console.error("[AUTH] Failed to mark token as used:", tokenUseError);
+          throw tokenUseError;
+        }
       }
 
+      console.log("[AUTH] Clinic admin signup completed successfully", {
+        userId: user.uid,
+      });
       return user;
     } catch (error) {
       if (error instanceof z.ZodError) {
+        console.error(
+          "[AUTH] Zod validation error in signUpClinicAdmin:",
+          JSON.stringify(error.errors, null, 2)
+        );
         throw AUTH_ERRORS.VALIDATION_ERROR;
       }
 
       const firebaseError = error as FirebaseError;
       if (firebaseError.code === FirebaseErrorCode.EMAIL_ALREADY_IN_USE) {
+        console.error("[AUTH] Email already in use:", data.email);
         throw AUTH_ERRORS.EMAIL_ALREADY_EXISTS;
       }
 
+      console.error("[AUTH] Unhandled error in signUpClinicAdmin:", error);
       throw error;
     }
   }

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

@@ -38,21 +38,55 @@ export async function createClinicAdmin(
   data: CreateClinicAdminData,
   clinicGroupService: any
 ): Promise<ClinicAdmin> {
+  console.log("[CLINIC_ADMIN] Starting clinic admin creation", {
+    userRef: data.userRef,
+  });
+  console.log("[CLINIC_ADMIN] Input data:", JSON.stringify(data, null, 2));
+
   // Validacija podataka
+  try {
+    const validatedData = createClinicAdminSchema.parse(data);
+    console.log("[CLINIC_ADMIN] Data validation passed");
+  } catch (validationError) {
+    console.error("[CLINIC_ADMIN] Data validation failed:", validationError);
+    throw validationError;
+  }
+
   const validatedData = createClinicAdminSchema.parse(data);
 
   // Proveravamo da li korisnik već ima admin profil
-  const existingAdmin = await getClinicAdminByUserRef(
-    db,
-    validatedData.userRef
-  );
-  if (existingAdmin) {
-    throw new Error("User already has an admin profile");
+  console.log("[CLINIC_ADMIN] Checking if user already has an admin profile", {
+    userRef: validatedData.userRef,
+  });
+  try {
+    const existingAdmin = await getClinicAdminByUserRef(
+      db,
+      validatedData.userRef
+    );
+    if (existingAdmin) {
+      console.error("[CLINIC_ADMIN] User already has an admin profile", {
+        adminId: existingAdmin.id,
+      });
+      throw new Error("User already has an admin profile");
+    }
+    console.log("[CLINIC_ADMIN] User does not have an existing admin profile");
+  } catch (error: any) {
+    if (error.message === "User already has an admin profile") {
+      throw error;
+    }
+    console.error("[CLINIC_ADMIN] Error checking for existing admin:", error);
+    throw error;
   }
 
   // Ako je owner, kreiramo default grupu ako nije prosleđen groupId
   let clinicGroupId = validatedData.clinicGroupId;
+  console.log("[CLINIC_ADMIN] Checking clinic group situation", {
+    isGroupOwner: validatedData.isGroupOwner,
+    hasGroupId: !!clinicGroupId,
+  });
+
   if (validatedData.isGroupOwner && !clinicGroupId) {
+    console.log("[CLINIC_ADMIN] Creating default group for owner");
     // Kreiramo default grupu
     const defaultGroup: CreateDefaultClinicGroupData = {
       name: `${validatedData.contactInfo.firstName}'s Group`,
@@ -60,7 +94,7 @@ export async function createClinicAdmin(
       contactPerson: validatedData.contactInfo,
       contactInfo: {
         email: validatedData.contactInfo.email,
-        phoneNumber: validatedData.contactInfo.phoneNumber,
+        phoneNumber: validatedData.contactInfo.phoneNumber || "",
       },
       hqLocation: {
         address: "",
@@ -72,37 +106,77 @@ export async function createClinicAdmin(
       },
       isActive: true,
     };
-
-    const clinicGroup = await clinicGroupService.createClinicGroup(
-      defaultGroup,
-      validatedData.userRef,
-      true
-    );
-    clinicGroupId = clinicGroup.id;
+    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;
+    }
   }
   // Ako nije owner a nemamo groupId, to je greška
   else if (!validatedData.isGroupOwner && !clinicGroupId) {
+    console.error("[CLINIC_ADMIN] Missing clinic group ID for non-owner admin");
     throw new Error("Clinic group ID is required for non-owner admins");
   }
   // Ako nije owner a imamo groupId, proverimo da li grupa postoji
   else if (!validatedData.isGroupOwner && clinicGroupId) {
-    const groupExists = await checkClinicGroupExists(
-      db,
-      clinicGroupId,
-      clinicGroupService
-    );
-    if (!groupExists) {
-      throw new Error("Specified clinic group does not exist");
+    console.log("[CLINIC_ADMIN] Checking if specified clinic group exists", {
+      groupId: clinicGroupId,
+    });
+    try {
+      const groupExists = await checkClinicGroupExists(
+        db,
+        clinicGroupId,
+        clinicGroupService
+      );
+      if (!groupExists) {
+        console.error("[CLINIC_ADMIN] Specified clinic group does not exist", {
+          groupId: clinicGroupId,
+        });
+        throw new Error("Specified clinic group does not exist");
+      }
+      console.log("[CLINIC_ADMIN] Specified clinic group exists");
+    } catch (groupCheckError) {
+      console.error(
+        "[CLINIC_ADMIN] Error checking if clinic group exists:",
+        groupCheckError
+      );
+      throw groupCheckError;
     }
   }
 
+  console.log("[CLINIC_ADMIN] Preparing admin data object");
+
+  // Ensure clinicGroupId is not undefined
+  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: Omit<ClinicAdmin, "createdAt" | "updatedAt"> & {
     createdAt: ReturnType<typeof serverTimestamp>;
     updatedAt: ReturnType<typeof serverTimestamp>;
   } = {
     id: validatedData.userRef,
     userRef: validatedData.userRef,
-    clinicGroupId: clinicGroupId!,
+    clinicGroupId: clinicGroupId,
     isGroupOwner: validatedData.isGroupOwner,
     clinicsManaged: [], // Uvek krećemo od prazne liste
     clinicsManagedInfo: [], // Empty array for clinic info
@@ -114,27 +188,74 @@ export async function createClinicAdmin(
   };
 
   // Validacija kompletnog objekta
-  clinicAdminSchema.parse({
-    ...adminData,
-    createdAt: Timestamp.now(),
-    updatedAt: Timestamp.now(),
-  });
+  console.log("[CLINIC_ADMIN] Validating complete admin object");
+  try {
+    clinicAdminSchema.parse({
+      ...adminData,
+      createdAt: Timestamp.now(),
+      updatedAt: Timestamp.now(),
+    });
+    console.log("[CLINIC_ADMIN] Admin object validation passed");
+  } catch (schemaError) {
+    console.error(
+      "[CLINIC_ADMIN] Admin object validation failed:",
+      JSON.stringify(schemaError, null, 2)
+    );
+    throw schemaError;
+  }
 
   // Čuvamo u Firestore
-  await setDoc(doc(db, CLINIC_ADMINS_COLLECTION, adminData.id), adminData);
+  console.log("[CLINIC_ADMIN] Saving admin to Firestore", {
+    adminId: adminData.id,
+  });
+  try {
+    await setDoc(doc(db, CLINIC_ADMINS_COLLECTION, adminData.id), adminData);
+    console.log("[CLINIC_ADMIN] Admin saved successfully");
+  } catch (firestoreError) {
+    console.error(
+      "[CLINIC_ADMIN] Error saving admin to Firestore:",
+      firestoreError
+    );
+    throw firestoreError;
+  }
 
   // Dodajemo admina u grupu
   if (clinicGroupId) {
-    await clinicGroupService.addAdminToGroup(clinicGroupId, adminData.id);
+    console.log("[CLINIC_ADMIN] Adding admin to clinic group", {
+      adminId: adminData.id,
+      groupId: clinicGroupId,
+    });
+    try {
+      await clinicGroupService.addAdminToGroup(clinicGroupId, adminData.id);
+      console.log("[CLINIC_ADMIN] Admin added to group successfully");
+    } catch (addToGroupError) {
+      console.error(
+        "[CLINIC_ADMIN] Error adding admin to group:",
+        addToGroupError
+      );
+      throw addToGroupError;
+    }
   }
 
   // Vraćamo kreirani objekat
-  const createdAdmin = await getClinicAdmin(db, adminData.id);
-  if (!createdAdmin) {
-    throw new Error("Failed to retrieve created admin");
+  console.log("[CLINIC_ADMIN] Retrieving created admin");
+  try {
+    const createdAdmin = await getClinicAdmin(db, adminData.id);
+    if (!createdAdmin) {
+      console.error("[CLINIC_ADMIN] Failed to retrieve created admin");
+      throw new Error("Failed to retrieve created admin");
+    }
+    console.log("[CLINIC_ADMIN] Admin creation completed successfully", {
+      adminId: createdAdmin.id,
+    });
+    return createdAdmin;
+  } catch (retrieveError) {
+    console.error(
+      "[CLINIC_ADMIN] Error retrieving created admin:",
+      retrieveError
+    );
+    throw retrieveError;
   }
-
-  return createdAdmin;
 }
 
 /**

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

@@ -59,24 +59,65 @@ export async function createClinicGroup(
   isDefault: boolean = false,
   clinicAdminService: any
 ): Promise<ClinicGroup> {
+  console.log("[CLINIC_GROUP] Starting clinic group creation", {
+    ownerId,
+    isDefault,
+  });
+  console.log("[CLINIC_GROUP] Input data:", JSON.stringify(data, null, 2));
+
   // Validacija podataka
+  try {
+    const validatedData = createClinicGroupSchema.parse(data);
+    console.log("[CLINIC_GROUP] Data validation passed");
+  } catch (validationError) {
+    console.error("[CLINIC_GROUP] Data validation failed:", validationError);
+    throw validationError;
+  }
+
   const validatedData = createClinicGroupSchema.parse(data);
 
   // Proveravamo da li owner postoji i da li je clinic admin
-  const owner = await clinicAdminService.getClinicAdmin(ownerId);
-  if (!owner) {
-    throw new Error("Owner not found or is not a 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");
+    }
+    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) {
-    validatedData.hqLocation.geohash = geohashForLocation([
-      validatedData.hqLocation.latitude,
-      validatedData.hqLocation.longitude,
-    ]);
+    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");
+
+  // 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,
+  });
+
   const groupData: ClinicGroup = {
     ...validatedData,
     id: doc(collection(db, CLINIC_GROUPS_COLLECTION)).id,
@@ -107,22 +148,68 @@ export async function createClinicGroup(
 
   try {
     // Validiramo kompletan objekat
-    clinicGroupSchema.parse(groupData);
+    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
-    await setDoc(doc(db, CLINIC_GROUPS_COLLECTION, groupData.id), groupData);
+    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
-    await clinicAdminService.updateClinicAdmin(ownerId, {
-      clinicGroupId: groupData.id,
-      isGroupOwner: true,
+    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;
   }
 }