@blackcode_sa/metaestetics-api 1.4.6 → 1.4.8

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,16 +194,43 @@ 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"
           );
         }
 
-        // Create clinic group
+        // First create the clinic admin
+        console.log("[AUTH] Creating clinic admin first");
+        const createClinicAdminData: CreateClinicAdminData = {
+          userRef: firebaseUser.uid,
+          isGroupOwner: true,
+          clinicsManaged: [],
+          contactInfo: contactPerson,
+          roleTitle: data.title,
+          isActive: true,
+        };
+
+        try {
+          await clinicAdminService.createClinicAdmin(createClinicAdminData);
+          console.log("[AUTH] Clinic admin created successfully");
+        } catch (adminCreationError) {
+          console.error(
+            "[AUTH] Clinic admin creation failed:",
+            adminCreationError
+          );
+          throw adminCreationError;
+        }
+
+        // Then create clinic group
         const createClinicGroupData: CreateClinicGroupData = {
           name: data.clinicGroupData.name,
           hqLocation: data.clinicGroupData.hqLocation,
@@ -180,22 +243,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 +284,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 +344,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;
 }
 
 /**