@blackcode_sa/metaestetics-api 1.13.20 → 1.14.0

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

@@ -1002,6 +1002,179 @@ 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);
+        
+        const existingUser = await this.userService.getUserById(firebaseUser.uid);
+        if (!existingUser) {
+          await firebaseSignOut(this.auth);
+          throw new AuthError(
+            'No account found. Please contact support.',
+            'AUTH/USER_NOT_FOUND',
+            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');
+      const draftProfiles = await practitionerService.getDraftProfilesByEmail(normalizedEmail);
+
+      let user: User;
+      if (existingUser) {
+        // User exists - use existing account
+        user = existingUser;
+        console.log('[AUTH] Using existing user account');
+      } else {
+        // Create new user document
+        user = await this.userService.createUser(firebaseUser, [UserRole.PRACTITIONER], {
+          skipProfileCreation: true,
+        });
+        console.log('[AUTH] Created new user account');
+      }
+
+      // 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) {
+      console.error('[AUTH] Error in signUpPractitionerWithGoogle:', error);
+      if (error instanceof AuthError) {
+        throw error;
+      }
+      throw handleFirebaseError(error);
+    }
+  }
+
   /**
    * 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

@@ -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
    */
@@ -1546,6 +1864,10 @@ export class PractitionerService extends BaseService {
     clinicId: string
   ): Promise<void> {
     try {
+      console.log(
+        `[EnableFreeConsultation] Starting for practitioner ${practitionerId} in clinic ${clinicId}`
+      );
+
       // First, ensure the free consultation infrastructure exists
       await this.ensureFreeConsultationInfrastructure();
 
@@ -1573,9 +1895,15 @@ export class PractitionerService extends BaseService {
         );
       }
 
-      // Get all procedures for this practitioner (including inactive ones)
+      // CRITICAL: Double-check for existing procedures to prevent race conditions
+      // Fetch procedures again right before creation/update
+      // IMPORTANT: Pass false for excludeDraftPractitioners to work with draft practitioners
       const [activeProcedures, inactiveProcedures] = await Promise.all([
-        this.getProcedureService().getProceduresByPractitioner(practitionerId),
+        this.getProcedureService().getProceduresByPractitioner(
+          practitionerId,
+          undefined, // clinicBranchId
+          false // excludeDraftPractitioners - allow draft practitioners
+        ),
         this.getProcedureService().getInactiveProceduresByPractitioner(
           practitionerId
         ),
@@ -1585,31 +1913,86 @@ export class PractitionerService extends BaseService {
       const allProcedures = [...activeProcedures, ...inactiveProcedures];
 
       // Check if free consultation already exists (active or inactive)
-      const existingConsultation = allProcedures.find(
+      const existingConsultations = allProcedures.filter(
         (procedure) =>
           procedure.technology.id === "free-consultation-tech" &&
           procedure.clinicBranchId === clinicId
       );
 
+      console.log(
+        `[EnableFreeConsultation] Found ${existingConsultations.length} existing free consultation(s)`
+      );
+
+      // If multiple consultations exist, log a warning and clean up duplicates
+      if (existingConsultations.length > 1) {
+        console.warn(
+          `[EnableFreeConsultation] WARNING: Found ${existingConsultations.length} duplicate free consultations for practitioner ${practitionerId} in clinic ${clinicId}`
+        );
+        // Keep the first one, deactivate the rest
+        for (let i = 1; i < existingConsultations.length; i++) {
+          console.log(
+            `[EnableFreeConsultation] Deactivating duplicate consultation ${existingConsultations[i].id}`
+          );
+          await this.getProcedureService().deactivateProcedure(
+            existingConsultations[i].id
+          );
+        }
+      }
+
+      const existingConsultation = existingConsultations[0];
+
       if (existingConsultation) {
         if (existingConsultation.isActive) {
           console.log(
-            `Free consultation already active for practitioner ${practitionerId} in clinic ${clinicId}`
+            `[EnableFreeConsultation] Free consultation already active for practitioner ${practitionerId} in clinic ${clinicId}`
           );
           return;
         } else {
           // Reactivate the existing disabled consultation
+          console.log(
+            `[EnableFreeConsultation] Reactivating existing consultation ${existingConsultation.id}`
+          );
           await this.getProcedureService().updateProcedure(
             existingConsultation.id,
             { isActive: true }
           );
           console.log(
-            `Reactivated existing free consultation for practitioner ${practitionerId} in clinic ${clinicId}`
+            `[EnableFreeConsultation] Reactivated existing free consultation for practitioner ${practitionerId} in clinic ${clinicId}`
           );
           return;
         }
       }
 
+      // Final check before creating - race condition guard
+      // Fetch one more time to ensure no procedure was created in parallel
+      console.log(
+        `[EnableFreeConsultation] Final race condition check before creating new procedure`
+      );
+      const finalCheckProcedures =
+        await this.getProcedureService().getProceduresByPractitioner(
+          practitionerId,
+          undefined, // clinicBranchId
+          false // excludeDraftPractitioners - allow draft practitioners
+        );
+      const raceConditionCheck = finalCheckProcedures.find(
+        (procedure) =>
+          procedure.technology.id === "free-consultation-tech" &&
+          procedure.clinicBranchId === clinicId
+      );
+
+      if (raceConditionCheck) {
+        console.log(
+          `[EnableFreeConsultation] Race condition detected! Procedure was created by another request. Using existing procedure ${raceConditionCheck.id}`
+        );
+        if (!raceConditionCheck.isActive) {
+          await this.getProcedureService().updateProcedure(
+            raceConditionCheck.id,
+            { isActive: true }
+          );
+        }
+        return;
+      }
+
       // Create procedure data for free consultation (without productId or productsMetadata)
       const consultationData: Omit<CreateProcedureData, "productId"> = {
         name: "Free Consultation",
@@ -1631,16 +2014,19 @@ export class PractitionerService extends BaseService {
       };
 
       // Create the consultation procedure using the special method
+      console.log(
+        `[EnableFreeConsultation] Creating new free consultation procedure`
+      );
       await this.getProcedureService().createConsultationProcedure(
         consultationData
       );
 
       console.log(
-        `Free consultation enabled for practitioner ${practitionerId} in clinic ${clinicId}`
+        `[EnableFreeConsultation] Successfully created free consultation for practitioner ${practitionerId} in clinic ${clinicId}`
       );
     } catch (error) {
       console.error(
-        `Error enabling free consultation for practitioner ${practitionerId} in clinic ${clinicId}:`,
+        `[EnableFreeConsultation] Error enabling free consultation for practitioner ${practitionerId} in clinic ${clinicId}:`,
         error
       );
       throw error;
@@ -1764,10 +2150,18 @@ export class PractitionerService extends BaseService {
 
       // Find the free consultation procedure for this practitioner in this clinic
       // Use the more specific search by technology ID instead of name
+      // IMPORTANT: Pass false for excludeDraftPractitioners to allow disabling for draft practitioners
       const existingProcedures =
         await this.getProcedureService().getProceduresByPractitioner(
-          practitionerId
+          practitionerId,
+          undefined, // clinicBranchId (optional)
+          false // excludeDraftPractitioners - must be false to find procedures for draft practitioners
         );
+      
+      console.log(
+        `[DisableFreeConsultation] Found ${existingProcedures.length} procedures for practitioner ${practitionerId}`
+      );
+      
       const freeConsultation = existingProcedures.find(
         (procedure) =>
           procedure.technology.id === "free-consultation-tech" &&
@@ -1777,10 +2171,24 @@ export class PractitionerService extends BaseService {
 
       if (!freeConsultation) {
         console.log(
-          `No active free consultation found for practitioner ${practitionerId} in clinic ${clinicId}`
+          `[DisableFreeConsultation] No active free consultation found for practitioner ${practitionerId} in clinic ${clinicId}`
+        );
+        console.log(
+          `[DisableFreeConsultation] Existing procedures:`,
+          existingProcedures.map(p => ({
+            id: p.id,
+            name: p.name,
+            technologyId: p.technology?.id,
+            clinicBranchId: p.clinicBranchId,
+            isActive: p.isActive
+          }))
         );
         return;
       }
+      
+      console.log(
+        `[DisableFreeConsultation] Found free consultation procedure ${freeConsultation.id}, deactivating...`
+      );
 
       // Deactivate the consultation procedure
       await this.getProcedureService().deactivateProcedure(freeConsultation.id);