@blackcode_sa/metaestetics-api 1.13.21 → 1.14.1

package/src/services/auth/auth.service.ts

@@ -1002,6 +1002,296 @@ export class AuthService extends BaseService {
     }
   }
 
+  /**
+   * Signs up or signs in a practitioner with Google authentication.
+   * Checks for existing practitioner account or draft profiles.
+   * 
+   * @param idToken - The Google ID token obtained from the mobile app
+   * @returns Object containing user, practitioner (if exists), and draft profiles (if any)
+   */
+  async signUpPractitionerWithGoogle(
+    idToken: string
+  ): Promise<{
+    user: User;
+    practitioner: Practitioner | null;
+    draftProfiles: Practitioner[];
+  }> {
+    try {
+      console.log('[AUTH] Starting practitioner Google Sign-In/Sign-Up');
+
+      // Extract email from Google ID token
+      let email: string | undefined;
+      try {
+        const payloadBase64 = idToken.split('.')[1];
+        const payloadJson = globalThis.atob
+          ? globalThis.atob(payloadBase64)
+          : Buffer.from(payloadBase64, 'base64').toString('utf8');
+        const payload = JSON.parse(payloadJson);
+        email = payload.email as string | undefined;
+      } catch (decodeError) {
+        console.error('[AUTH] Failed to decode email from Google ID token:', decodeError);
+        throw new AuthError(
+          'Unable to read email from Google token. Please try again.',
+          'AUTH/INVALID_GOOGLE_TOKEN',
+          400,
+        );
+      }
+
+      if (!email) {
+        throw new AuthError(
+          'Unable to read email from Google token. Please try again.',
+          'AUTH/INVALID_GOOGLE_TOKEN',
+          400,
+        );
+      }
+
+      const normalizedEmail = email.toLowerCase().trim();
+      console.log('[AUTH] Extracted email from Google token:', normalizedEmail);
+
+      // Check if user already exists in Firebase Auth
+      const methods = await fetchSignInMethodsForEmail(this.auth, normalizedEmail);
+      const hasGoogleMethod = methods.includes(GoogleAuthProvider.GOOGLE_SIGN_IN_METHOD);
+      const hasEmailMethod = methods.includes(EmailAuthProvider.EMAIL_PASSWORD_SIGN_IN_METHOD);
+
+      const practitionerService = new PractitionerService(this.db, this.auth, this.app);
+
+      // Case 1: User exists with Google provider - sign in and check for practitioner profile
+      if (hasGoogleMethod) {
+        console.log('[AUTH] User exists with Google provider, signing in');
+        const credential = GoogleAuthProvider.credential(idToken);
+        const { user: firebaseUser } = await signInWithCredential(this.auth, credential);
+        
+        let existingUser: User | null = null;
+        try {
+          existingUser = await this.userService.getUserById(firebaseUser.uid);
+          console.log('[AUTH] User document found:', existingUser.uid);
+        } catch (userError: any) {
+          // User document doesn't exist in Firestore
+          console.log('[AUTH] User document not found in Firestore, checking for draft profiles', {
+            errorCode: userError?.code,
+            errorMessage: userError?.message,
+            errorType: userError?.constructor?.name,
+            isAuthError: userError instanceof AuthError,
+          });
+          
+          // Check for draft profiles before signing out
+          const practitionerService = new PractitionerService(this.db, this.auth, this.app);
+          const draftProfiles = await practitionerService.getDraftProfilesByEmail(normalizedEmail);
+          
+          console.log('[AUTH] Draft profiles check result:', {
+            email: normalizedEmail,
+            draftProfilesCount: draftProfiles.length,
+            draftProfileIds: draftProfiles.map(p => p.id),
+          });
+          
+          if (draftProfiles.length === 0) {
+            // No draft profiles - sign out and throw error
+            console.log('[AUTH] No draft profiles found, signing out and throwing error');
+            try {
+              await firebaseSignOut(this.auth);
+            } catch (signOutError) {
+              console.warn('[AUTH] Error signing out Firebase user (non-critical):', signOutError);
+            }
+            throw new AuthError(
+              'No clinic invitation found for this email. Please contact your clinic administrator to receive an invitation, or use the token provided by your clinic.',
+              'AUTH/NO_DRAFT_PROFILES',
+              404,
+            );
+          }
+          
+          // Draft profiles exist - create user document and continue
+          console.log('[AUTH] Draft profiles found, creating user document');
+          existingUser = await this.userService.createUser(firebaseUser, [UserRole.PRACTITIONER], {
+            skipProfileCreation: true,
+          });
+          console.log('[AUTH] Created user document for existing Firebase user with draft profiles:', existingUser.uid);
+        }
+        
+        if (!existingUser) {
+          await firebaseSignOut(this.auth);
+          throw new AuthError(
+            'No clinic invitation found for this email. Please contact your clinic administrator to receive an invitation, or use the token provided by your clinic.',
+            'AUTH/NO_DRAFT_PROFILES',
+            404,
+          );
+        }
+
+        // Check if user has practitioner profile
+        let practitioner: Practitioner | null = null;
+        if (existingUser.practitionerProfile) {
+          practitioner = await practitionerService.getPractitioner(existingUser.practitionerProfile);
+        }
+
+        // Check for any new draft profiles
+        const draftProfiles = await practitionerService.getDraftProfilesByEmail(normalizedEmail);
+
+        return {
+          user: existingUser,
+          practitioner,
+          draftProfiles,
+        };
+      }
+
+      // Case 2: User exists with email/password - need to link Google provider
+      // Firebase doesn't allow linking without being signed in first
+      // So we need to ask user to sign in with email/password first, then link
+      if (hasEmailMethod && !hasGoogleMethod) {
+        console.log('[AUTH] User exists with email/password only');
+        throw new AuthError(
+          'An account with this email already exists. Please sign in with your email and password, then link your Google account in settings.',
+          'AUTH/EMAIL_ALREADY_EXISTS',
+          409,
+        );
+      }
+
+      // Case 3: New user - sign in with Google and check for draft profiles
+      console.log('[AUTH] Signing in with Google credential');
+      const credential = GoogleAuthProvider.credential(idToken);
+      
+      let firebaseUser: FirebaseUser;
+      try {
+        const result = await signInWithCredential(this.auth, credential);
+        firebaseUser = result.user;
+      } catch (error: any) {
+        // If sign-in fails because email already exists with different provider
+        if (error.code === 'auth/account-exists-with-different-credential') {
+          throw new AuthError(
+            'An account with this email already exists. Please sign in with your email and password, then link your Google account in settings.',
+            'AUTH/EMAIL_ALREADY_EXISTS',
+            409,
+          );
+        }
+        throw error;
+      }
+
+      // Check for existing User document (in case user had email/password account that was just linked)
+      let existingUser: User | null = null;
+      try {
+        const existingUserDoc = await this.userService.getUserById(firebaseUser.uid);
+        if (existingUserDoc) {
+          existingUser = existingUserDoc;
+          console.log('[AUTH] Found existing User document');
+        }
+      } catch (error) {
+        console.error('[AUTH] Error checking for existing user:', error);
+        // Continue with new user creation
+      }
+
+      // Check for draft profiles
+      console.log('[AUTH] Checking for draft profiles');
+      let draftProfiles: Practitioner[] = [];
+      try {
+        draftProfiles = await practitionerService.getDraftProfilesByEmail(normalizedEmail);
+        console.log('[AUTH] Draft profiles check complete', { count: draftProfiles.length });
+      } catch (draftCheckError: any) {
+        console.error('[AUTH] Error checking draft profiles:', draftCheckError);
+        // If checking draft profiles fails, sign out and throw appropriate error
+        try {
+          await firebaseSignOut(this.auth);
+        } catch (signOutError) {
+          console.warn('[AUTH] Error signing out Firebase user (non-critical):', signOutError);
+        }
+        throw new AuthError(
+          'No clinic invitation found for this email. Please contact your clinic administrator to receive an invitation, or use the token provided by your clinic.',
+          'AUTH/NO_DRAFT_PROFILES',
+          404,
+        );
+      }
+
+      let user: User;
+      if (existingUser) {
+        // User exists - use existing account
+        user = existingUser;
+        console.log('[AUTH] Using existing user account');
+      } else {
+        // For new users: Only create account if there are draft profiles OR if user already has a practitioner profile
+        // Since doctors can only join via clinic invitation, we should not create accounts without invitations
+        if (draftProfiles.length === 0) {
+          console.log('[AUTH] No draft profiles found, signing out and throwing error');
+          // Sign out the Firebase user since we're not creating an account
+          // Wrap in try-catch to handle any sign-out errors gracefully
+          try {
+            await firebaseSignOut(this.auth);
+          } catch (signOutError) {
+            console.warn('[AUTH] Error signing out Firebase user (non-critical):', signOutError);
+            // Continue anyway - the important part is we're not creating the account
+          }
+          const noDraftError = new AuthError(
+            'No clinic invitation found for this email. Please contact your clinic administrator to receive an invitation, or use the token provided by your clinic.',
+            'AUTH/NO_DRAFT_PROFILES',
+            404,
+          );
+          console.log('[AUTH] Throwing NO_DRAFT_PROFILES error:', noDraftError.code);
+          throw noDraftError;
+        }
+        
+        // Create new user document only if draft profiles exist
+        user = await this.userService.createUser(firebaseUser, [UserRole.PRACTITIONER], {
+          skipProfileCreation: true,
+        });
+        console.log('[AUTH] Created new user account with draft profiles available');
+      }
+
+      // Check if user already has practitioner profile
+      let practitioner: Practitioner | null = null;
+      if (user.practitionerProfile) {
+        practitioner = await practitionerService.getPractitioner(user.practitionerProfile);
+      }
+
+      console.log('[AUTH] Google Sign-In complete', {
+        userId: user.uid,
+        hasPractitioner: !!practitioner,
+        draftProfilesCount: draftProfiles.length,
+      });
+
+      return {
+        user,
+        practitioner,
+        draftProfiles,
+      };
+    } catch (error: any) {
+      console.error('[AUTH] Error in signUpPractitionerWithGoogle:', error);
+      console.error('[AUTH] Error type:', error?.constructor?.name);
+      console.error('[AUTH] Error instanceof AuthError:', error instanceof AuthError);
+      console.error('[AUTH] Error code:', error?.code);
+      console.error('[AUTH] Error message:', error?.message);
+      
+      // Preserve AuthError instances (like NO_DRAFT_PROFILES) without wrapping
+      if (error instanceof AuthError) {
+        console.log('[AUTH] Preserving AuthError:', error.code);
+        throw error;
+      }
+      
+      // Check if error message contains NO_DRAFT_PROFILES before wrapping
+      const errorMessage = error?.message || error?.toString() || '';
+      if (errorMessage.includes('NO_DRAFT_PROFILES') || errorMessage.includes('clinic invitation')) {
+        console.log('[AUTH] Detected clinic invitation error in message, converting to AuthError');
+        throw new AuthError(
+          'No clinic invitation found for this email. Please contact your clinic administrator to receive an invitation, or use the token provided by your clinic.',
+          'AUTH/NO_DRAFT_PROFILES',
+          404,
+        );
+      }
+      
+      // For other errors, wrap them but preserve the original message if it's helpful
+      const wrappedError = handleFirebaseError(error);
+      console.log('[AUTH] Wrapped error:', wrappedError.message);
+      
+      // If the wrapped error message is generic, try to preserve more context
+      if (wrappedError.message.includes('permissions') || wrappedError.message.includes('Account creation failed')) {
+        // This might be a permissions error during sign-out or user creation
+        // If we got here and there were no draft profiles, it's likely the same issue
+        throw new AuthError(
+          'No clinic invitation found for this email. Please contact your clinic administrator to receive an invitation, or use the token provided by your clinic.',
+          'AUTH/NO_DRAFT_PROFILES',
+          404,
+        );
+      }
+      
+      throw wrappedError;
+    }
+  }
+
   /**
    * Links a Google account to the currently signed-in user using an ID token.
    * This is used to upgrade an anonymous user or to allow an existing user

package/src/services/practitioner/practitioner.service.ts

@@ -158,6 +158,11 @@ export class PractitionerService extends BaseService {
   ): Promise<PractitionerBasicInfo> {
     const processedBasicInfo = { ...basicInfo };
 
+    // Normalize email to lowercase to ensure consistent matching
+    if (processedBasicInfo.email) {
+      processedBasicInfo.email = processedBasicInfo.email.toLowerCase().trim();
+    }
+
     // Handle profile photo upload if needed
     if (basicInfo.profileImageUrl) {
       const uploadedUrl = await this.handleProfilePhotoUpload(
@@ -714,6 +719,344 @@ export class PractitionerService extends BaseService {
     }
   }
 
+  /**
+   * Finds all draft practitioner profiles by email address
+   * Used when a doctor signs in with Google to show all clinic invitations
+   * 
+   * @param email - Email address to search for
+   * @returns Array of draft practitioner profiles with clinic information
+   * 
+   * @remarks
+   * Requires Firestore composite index on:
+   * - Collection: practitioners
+   * - Fields: basicInfo.email (Ascending), status (Ascending), userRef (Ascending)
+   */
+  async getDraftProfilesByEmail(
+    email: string
+  ): Promise<Practitioner[]> {
+    try {
+      const normalizedEmail = email.toLowerCase().trim();
+      
+      console.log("[PRACTITIONER] Searching for all draft practitioners by email", {
+        email: normalizedEmail,
+        originalEmail: email,
+      });
+
+      const q = query(
+        collection(this.db, PRACTITIONERS_COLLECTION),
+        where("basicInfo.email", "==", normalizedEmail),
+        where("status", "==", PractitionerStatus.DRAFT),
+        where("userRef", "==", "")
+      );
+
+      const querySnapshot = await getDocs(q);
+      
+      if (querySnapshot.empty) {
+        console.log("[PRACTITIONER] No draft practitioners found for email", {
+          email: normalizedEmail,
+          originalEmail: email,
+        });
+        
+        // Debug: Try to find ANY practitioners with this email (regardless of status)
+        const debugQ = query(
+          collection(this.db, PRACTITIONERS_COLLECTION),
+          where("basicInfo.email", "==", normalizedEmail),
+          limit(5)
+        );
+        const debugSnapshot = await getDocs(debugQ);
+        console.log("[PRACTITIONER] Debug: Found practitioners with this email (any status):", {
+          count: debugSnapshot.size,
+          practitioners: debugSnapshot.docs.map(doc => ({
+            id: doc.id,
+            email: doc.data().basicInfo?.email,
+            status: doc.data().status,
+            userRef: doc.data().userRef,
+          })),
+        });
+        
+        return [];
+      }
+
+      const draftPractitioners = querySnapshot.docs.map(
+        (doc) => doc.data() as Practitioner
+      );
+      
+      console.log("[PRACTITIONER] Found draft practitioners", {
+        email: normalizedEmail,
+        count: draftPractitioners.length,
+        practitionerIds: draftPractitioners.map((p) => p.id),
+      });
+
+      return draftPractitioners;
+    } catch (error) {
+      console.error(
+        "[PRACTITIONER] Error finding draft practitioners by email:",
+        error
+      );
+      // If query fails (e.g., index not created), return empty array
+      return [];
+    }
+  }
+
+  /**
+   * Claims a draft practitioner profile and links it to a user account
+   * Used when a doctor selects which clinic(s) to join after Google Sign-In
+   * 
+   * @param practitionerId - ID of the draft practitioner profile to claim
+   * @param userId - ID of the user account to link the profile to
+   * @returns The claimed practitioner profile
+   */
+  async claimDraftProfileWithGoogle(
+    practitionerId: string,
+    userId: string
+  ): Promise<Practitioner> {
+    try {
+      console.log("[PRACTITIONER] Claiming draft profile with Google", {
+        practitionerId,
+        userId,
+      });
+
+      // Get the draft practitioner profile
+      const practitioner = await this.getPractitioner(practitionerId);
+      if (!practitioner) {
+        throw new Error(`Practitioner ${practitionerId} not found`);
+      }
+
+      // Ensure practitioner is in DRAFT status
+      if (practitioner.status !== PractitionerStatus.DRAFT) {
+        throw new Error("This practitioner profile has already been claimed");
+      }
+
+      // Check if user already has a practitioner profile
+      const existingPractitioner = await this.getPractitionerByUserRef(userId);
+      if (existingPractitioner) {
+        // User already has a profile - merge clinics from draft profile into existing profile
+        console.log("[PRACTITIONER] User already has profile, merging clinics");
+        
+        // Merge clinics (avoid duplicates)
+        const mergedClinics = Array.from(new Set([
+          ...existingPractitioner.clinics,
+          ...practitioner.clinics,
+        ]));
+        
+        // Merge clinic working hours
+        const mergedWorkingHours = [...existingPractitioner.clinicWorkingHours];
+        for (const workingHours of practitioner.clinicWorkingHours) {
+          if (!mergedWorkingHours.find(wh => wh.clinicId === workingHours.clinicId)) {
+            mergedWorkingHours.push(workingHours);
+          }
+        }
+        
+        // Merge clinics info (avoid duplicates)
+        const mergedClinicsInfo = [...existingPractitioner.clinicsInfo];
+        for (const clinicInfo of practitioner.clinicsInfo) {
+          if (!mergedClinicsInfo.find(ci => ci.id === clinicInfo.id)) {
+            mergedClinicsInfo.push(clinicInfo);
+          }
+        }
+        
+        // Update existing practitioner with merged data
+        const updatedPractitioner = await this.updatePractitioner(existingPractitioner.id, {
+          clinics: mergedClinics,
+          clinicWorkingHours: mergedWorkingHours,
+          clinicsInfo: mergedClinicsInfo,
+        });
+        
+        // Delete the draft profile since we've merged it
+        await deleteDoc(doc(this.db, PRACTITIONERS_COLLECTION, practitionerId));
+        
+        // Mark all active tokens for the draft practitioner as used
+        const activeTokens = await this.getPractitionerActiveTokens(practitionerId);
+        for (const token of activeTokens) {
+          await this.markTokenAsUsed(token.id, practitionerId, userId);
+        }
+        
+        return updatedPractitioner;
+      }
+
+      // Claim the profile by linking it to the user
+      const updatedPractitioner = await this.updatePractitioner(practitioner.id, {
+        userRef: userId,
+        status: PractitionerStatus.ACTIVE,
+      });
+
+      // Mark all active tokens for this practitioner as used
+      const activeTokens = await this.getPractitionerActiveTokens(practitionerId);
+      for (const token of activeTokens) {
+        await this.markTokenAsUsed(token.id, practitionerId, userId);
+      }
+
+      console.log("[PRACTITIONER] Draft profile claimed successfully", {
+        practitionerId: updatedPractitioner.id,
+        userId,
+      });
+
+      return updatedPractitioner;
+    } catch (error) {
+      console.error(
+        "[PRACTITIONER] Error claiming draft profile with Google:",
+        error
+      );
+      throw error;
+    }
+  }
+
+  /**
+   * Claims multiple draft practitioner profiles and merges them into one profile
+   * Used when a doctor selects multiple clinics to join after Google Sign-In
+   * 
+   * @param practitionerIds - Array of draft practitioner profile IDs to claim
+   * @param userId - ID of the user account to link the profiles to
+   * @returns The claimed practitioner profile (first one becomes main, others merged)
+   */
+  async claimMultipleDraftProfilesWithGoogle(
+    practitionerIds: string[],
+    userId: string
+  ): Promise<Practitioner> {
+    try {
+      if (practitionerIds.length === 0) {
+        throw new Error("No practitioner IDs provided");
+      }
+
+      console.log("[PRACTITIONER] Claiming multiple draft profiles with Google", {
+        practitionerIds,
+        userId,
+        count: practitionerIds.length,
+      });
+
+      // Get all draft profiles
+      const draftProfiles = await Promise.all(
+        practitionerIds.map(id => this.getPractitioner(id))
+      );
+
+      // Filter out nulls and ensure all are drafts
+      const validDrafts = draftProfiles.filter((p): p is Practitioner => {
+        if (!p) return false;
+        if (p.status !== PractitionerStatus.DRAFT) {
+          throw new Error(`Practitioner ${p.id} has already been claimed`);
+        }
+        return true;
+      });
+
+      if (validDrafts.length === 0) {
+        throw new Error("No valid draft profiles found");
+      }
+
+      // Check if user already has a practitioner profile
+      const existingPractitioner = await this.getPractitionerByUserRef(userId);
+      
+      if (existingPractitioner) {
+        // Merge all draft profiles into existing profile
+        let mergedClinics = new Set(existingPractitioner.clinics);
+        let mergedWorkingHours = [...existingPractitioner.clinicWorkingHours];
+        let mergedClinicsInfo = [...existingPractitioner.clinicsInfo];
+
+        for (const draft of validDrafts) {
+          // Merge clinics
+          draft.clinics.forEach(clinicId => mergedClinics.add(clinicId));
+          
+          // Merge working hours
+          for (const workingHours of draft.clinicWorkingHours) {
+            if (!mergedWorkingHours.find(wh => wh.clinicId === workingHours.clinicId)) {
+              mergedWorkingHours.push(workingHours);
+            }
+          }
+          
+          // Merge clinics info
+          for (const clinicInfo of draft.clinicsInfo) {
+            if (!mergedClinicsInfo.find(ci => ci.id === clinicInfo.id)) {
+              mergedClinicsInfo.push(clinicInfo);
+            }
+          }
+        }
+
+        // Update existing practitioner
+        const updatedPractitioner = await this.updatePractitioner(existingPractitioner.id, {
+          clinics: Array.from(mergedClinics),
+          clinicWorkingHours: mergedWorkingHours,
+          clinicsInfo: mergedClinicsInfo,
+        });
+
+        // Delete all draft profiles
+        for (const draft of validDrafts) {
+          await deleteDoc(doc(this.db, PRACTITIONERS_COLLECTION, draft.id));
+          
+          // Mark all active tokens as used
+          const activeTokens = await this.getPractitionerActiveTokens(draft.id);
+          for (const token of activeTokens) {
+            await this.markTokenAsUsed(token.id, draft.id, userId);
+          }
+        }
+
+        return updatedPractitioner;
+      }
+
+      // Use first draft as the main profile, merge others into it
+      const mainDraft = validDrafts[0];
+      const otherDrafts = validDrafts.slice(1);
+
+      // Merge clinics from other drafts
+      let mergedClinics = new Set(mainDraft.clinics);
+      let mergedWorkingHours = [...mainDraft.clinicWorkingHours];
+      let mergedClinicsInfo = [...mainDraft.clinicsInfo];
+
+      for (const draft of otherDrafts) {
+        draft.clinics.forEach(clinicId => mergedClinics.add(clinicId));
+        
+        for (const workingHours of draft.clinicWorkingHours) {
+          if (!mergedWorkingHours.find(wh => wh.clinicId === workingHours.clinicId)) {
+            mergedWorkingHours.push(workingHours);
+          }
+        }
+        
+        for (const clinicInfo of draft.clinicsInfo) {
+          if (!mergedClinicsInfo.find(ci => ci.id === clinicInfo.id)) {
+            mergedClinicsInfo.push(clinicInfo);
+          }
+        }
+      }
+
+      // Claim the main profile
+      const updatedPractitioner = await this.updatePractitioner(mainDraft.id, {
+        userRef: userId,
+        status: PractitionerStatus.ACTIVE,
+        clinics: Array.from(mergedClinics),
+        clinicWorkingHours: mergedWorkingHours,
+        clinicsInfo: mergedClinicsInfo,
+      });
+
+      // Mark all active tokens for main profile as used
+      const mainActiveTokens = await this.getPractitionerActiveTokens(mainDraft.id);
+      for (const token of mainActiveTokens) {
+        await this.markTokenAsUsed(token.id, mainDraft.id, userId);
+      }
+
+      // Delete other draft profiles
+      for (const draft of otherDrafts) {
+        await deleteDoc(doc(this.db, PRACTITIONERS_COLLECTION, draft.id));
+        
+        const activeTokens = await this.getPractitionerActiveTokens(draft.id);
+        for (const token of activeTokens) {
+          await this.markTokenAsUsed(token.id, draft.id, userId);
+        }
+      }
+
+      console.log("[PRACTITIONER] Multiple draft profiles claimed successfully", {
+        practitionerId: updatedPractitioner.id,
+        userId,
+        mergedCount: validDrafts.length,
+      });
+
+      return updatedPractitioner;
+    } catch (error) {
+      console.error(
+        "[PRACTITIONER] Error claiming multiple draft profiles with Google:",
+        error
+      );
+      throw error;
+    }
+  }
+
   /**
    * Dohvata sve zdravstvene radnike za određenu kliniku sa statusom ACTIVE
    */