@blackcode_sa/metaestetics-api 1.13.21 → 1.14.0

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

@@ -714,6 +714,324 @@ 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,
+      });
+
+      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,
+        });
+        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
    */