@blackcode_sa/metaestetics-api 1.13.20 → 1.14.0

package/dist/index.js

@@ -7838,7 +7838,7 @@ var contraindicationSchema = import_zod6.z.object({
   notes: import_zod6.z.string().optional().nullable(),
   isActive: import_zod6.z.boolean()
 });
-var medicationSchema = import_zod6.z.object({
+var baseMedicationSchema = import_zod6.z.object({
   name: import_zod6.z.string().min(1),
   dosage: import_zod6.z.string().min(1),
   frequency: import_zod6.z.string().min(1),
@@ -7846,6 +7846,24 @@ var medicationSchema = import_zod6.z.object({
   endDate: timestampSchema.optional().nullable(),
   prescribedBy: import_zod6.z.string().optional().nullable()
 });
+var medicationSchema = baseMedicationSchema.refine(
+  (data) => {
+    if (!data.endDate) {
+      return true;
+    }
+    if (!data.startDate) {
+      return false;
+    }
+    const startDate = data.startDate.toDate();
+    const endDate = data.endDate.toDate();
+    return endDate >= startDate;
+  },
+  {
+    message: "End date requires a start date and must be equal to or after start date",
+    path: ["endDate"]
+    // This will attach the error to the endDate field
+  }
+);
 var patientMedicalInfoSchema = import_zod6.z.object({
   patientId: import_zod6.z.string(),
   vitalStats: vitalStatsSchema,
@@ -7881,9 +7899,26 @@ var updateContraindicationSchema = contraindicationSchema.partial().extend({
   contraindicationIndex: import_zod6.z.number().min(0)
 });
 var addMedicationSchema = medicationSchema;
-var updateMedicationSchema = medicationSchema.partial().extend({
+var updateMedicationSchema = baseMedicationSchema.partial().extend({
   medicationIndex: import_zod6.z.number().min(0)
-});
+}).refine(
+  (data) => {
+    if (!data.endDate) {
+      return true;
+    }
+    if (!data.startDate) {
+      return false;
+    }
+    const startDate = data.startDate.toDate();
+    const endDate = data.endDate.toDate();
+    return endDate >= startDate;
+  },
+  {
+    message: "End date requires a start date and must be equal to or after start date",
+    path: ["endDate"]
+    // This will attach the error to the endDate field
+  }
+);
 
 // src/validations/patient.schema.ts
 var locationDataSchema = import_zod7.z.object({
@@ -11680,6 +11715,240 @@ var PractitionerService = class extends BaseService {
       return null;
     }
   }
+  /**
+   * 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) {
+    try {
+      const normalizedEmail = email.toLowerCase().trim();
+      console.log("[PRACTITIONER] Searching for all draft practitioners by email", {
+        email: normalizedEmail
+      });
+      const q = (0, import_firestore32.query)(
+        (0, import_firestore32.collection)(this.db, PRACTITIONERS_COLLECTION),
+        (0, import_firestore32.where)("basicInfo.email", "==", normalizedEmail),
+        (0, import_firestore32.where)("status", "==", "draft" /* DRAFT */),
+        (0, import_firestore32.where)("userRef", "==", "")
+      );
+      const querySnapshot = await (0, import_firestore32.getDocs)(q);
+      if (querySnapshot.empty) {
+        console.log("[PRACTITIONER] No draft practitioners found for email", {
+          email: normalizedEmail
+        });
+        return [];
+      }
+      const draftPractitioners = querySnapshot.docs.map(
+        (doc47) => doc47.data()
+      );
+      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
+      );
+      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, userId) {
+    try {
+      console.log("[PRACTITIONER] Claiming draft profile with Google", {
+        practitionerId,
+        userId
+      });
+      const practitioner = await this.getPractitioner(practitionerId);
+      if (!practitioner) {
+        throw new Error(`Practitioner ${practitionerId} not found`);
+      }
+      if (practitioner.status !== "draft" /* DRAFT */) {
+        throw new Error("This practitioner profile has already been claimed");
+      }
+      const existingPractitioner = await this.getPractitionerByUserRef(userId);
+      if (existingPractitioner) {
+        console.log("[PRACTITIONER] User already has profile, merging clinics");
+        const mergedClinics = Array.from(/* @__PURE__ */ new Set([
+          ...existingPractitioner.clinics,
+          ...practitioner.clinics
+        ]));
+        const mergedWorkingHours = [...existingPractitioner.clinicWorkingHours];
+        for (const workingHours of practitioner.clinicWorkingHours) {
+          if (!mergedWorkingHours.find((wh) => wh.clinicId === workingHours.clinicId)) {
+            mergedWorkingHours.push(workingHours);
+          }
+        }
+        const mergedClinicsInfo = [...existingPractitioner.clinicsInfo];
+        for (const clinicInfo of practitioner.clinicsInfo) {
+          if (!mergedClinicsInfo.find((ci) => ci.id === clinicInfo.id)) {
+            mergedClinicsInfo.push(clinicInfo);
+          }
+        }
+        const updatedPractitioner2 = await this.updatePractitioner(existingPractitioner.id, {
+          clinics: mergedClinics,
+          clinicWorkingHours: mergedWorkingHours,
+          clinicsInfo: mergedClinicsInfo
+        });
+        await (0, import_firestore32.deleteDoc)((0, import_firestore32.doc)(this.db, PRACTITIONERS_COLLECTION, practitionerId));
+        const activeTokens2 = await this.getPractitionerActiveTokens(practitionerId);
+        for (const token of activeTokens2) {
+          await this.markTokenAsUsed(token.id, practitionerId, userId);
+        }
+        return updatedPractitioner2;
+      }
+      const updatedPractitioner = await this.updatePractitioner(practitioner.id, {
+        userRef: userId,
+        status: "active" /* ACTIVE */
+      });
+      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, userId) {
+    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
+      });
+      const draftProfiles = await Promise.all(
+        practitionerIds.map((id) => this.getPractitioner(id))
+      );
+      const validDrafts = draftProfiles.filter((p) => {
+        if (!p) return false;
+        if (p.status !== "draft" /* 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");
+      }
+      const existingPractitioner = await this.getPractitionerByUserRef(userId);
+      if (existingPractitioner) {
+        let mergedClinics2 = new Set(existingPractitioner.clinics);
+        let mergedWorkingHours2 = [...existingPractitioner.clinicWorkingHours];
+        let mergedClinicsInfo2 = [...existingPractitioner.clinicsInfo];
+        for (const draft of validDrafts) {
+          draft.clinics.forEach((clinicId) => mergedClinics2.add(clinicId));
+          for (const workingHours of draft.clinicWorkingHours) {
+            if (!mergedWorkingHours2.find((wh) => wh.clinicId === workingHours.clinicId)) {
+              mergedWorkingHours2.push(workingHours);
+            }
+          }
+          for (const clinicInfo of draft.clinicsInfo) {
+            if (!mergedClinicsInfo2.find((ci) => ci.id === clinicInfo.id)) {
+              mergedClinicsInfo2.push(clinicInfo);
+            }
+          }
+        }
+        const updatedPractitioner2 = await this.updatePractitioner(existingPractitioner.id, {
+          clinics: Array.from(mergedClinics2),
+          clinicWorkingHours: mergedWorkingHours2,
+          clinicsInfo: mergedClinicsInfo2
+        });
+        for (const draft of validDrafts) {
+          await (0, import_firestore32.deleteDoc)((0, import_firestore32.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);
+          }
+        }
+        return updatedPractitioner2;
+      }
+      const mainDraft = validDrafts[0];
+      const otherDrafts = validDrafts.slice(1);
+      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);
+          }
+        }
+      }
+      const updatedPractitioner = await this.updatePractitioner(mainDraft.id, {
+        userRef: userId,
+        status: "active" /* ACTIVE */,
+        clinics: Array.from(mergedClinics),
+        clinicWorkingHours: mergedWorkingHours,
+        clinicsInfo: mergedClinicsInfo
+      });
+      const mainActiveTokens = await this.getPractitionerActiveTokens(mainDraft.id);
+      for (const token of mainActiveTokens) {
+        await this.markTokenAsUsed(token.id, mainDraft.id, userId);
+      }
+      for (const draft of otherDrafts) {
+        await (0, import_firestore32.deleteDoc)((0, import_firestore32.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
    */
@@ -12315,6 +12584,9 @@ var PractitionerService = class extends BaseService {
    */
   async EnableFreeConsultation(practitionerId, clinicId) {
     try {
+      console.log(
+        `[EnableFreeConsultation] Starting for practitioner ${practitionerId} in clinic ${clinicId}`
+      );
       await this.ensureFreeConsultationInfrastructure();
       const practitioner = await this.getPractitioner(practitionerId);
       if (!practitioner) {
@@ -12330,32 +12602,83 @@ var PractitionerService = class extends BaseService {
         );
       }
       const [activeProcedures, inactiveProcedures] = await Promise.all([
-        this.getProcedureService().getProceduresByPractitioner(practitionerId),
+        this.getProcedureService().getProceduresByPractitioner(
+          practitionerId,
+          void 0,
+          // clinicBranchId
+          false
+          // excludeDraftPractitioners - allow draft practitioners
+        ),
         this.getProcedureService().getInactiveProceduresByPractitioner(
           practitionerId
         )
       ]);
       const allProcedures = [...activeProcedures, ...inactiveProcedures];
-      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 (existingConsultations.length > 1) {
+        console.warn(
+          `[EnableFreeConsultation] WARNING: Found ${existingConsultations.length} duplicate free consultations for practitioner ${practitionerId} in clinic ${clinicId}`
+        );
+        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 {
+          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;
         }
       }
+      console.log(
+        `[EnableFreeConsultation] Final race condition check before creating new procedure`
+      );
+      const finalCheckProcedures = await this.getProcedureService().getProceduresByPractitioner(
+        practitionerId,
+        void 0,
+        // 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;
+      }
       const consultationData = {
         name: "Free Consultation",
         nameLower: "free consultation",
@@ -12375,15 +12698,18 @@ var PractitionerService = class extends BaseService {
         photos: []
         // No photos for consultation
       };
+      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;
@@ -12479,17 +12805,40 @@ var PractitionerService = class extends BaseService {
         );
       }
       const existingProcedures = await this.getProcedureService().getProceduresByPractitioner(
-        practitionerId
+        practitionerId,
+        void 0,
+        // 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" && procedure.clinicBranchId === clinicId && procedure.isActive
       );
       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) => {
+            var _a;
+            return {
+              id: p.id,
+              name: p.name,
+              technologyId: (_a = p.technology) == null ? void 0 : _a.id,
+              clinicBranchId: p.clinicBranchId,
+              isActive: p.isActive
+            };
+          })
         );
         return;
       }
+      console.log(
+        `[DisableFreeConsultation] Found free consultation procedure ${freeConsultation.id}, deactivating...`
+      );
       await this.getProcedureService().deactivateProcedure(freeConsultation.id);
       console.log(
         `Free consultation disabled for practitioner ${practitionerId} in clinic ${clinicId}`
@@ -15672,6 +16021,135 @@ var AuthService = class extends BaseService {
       throw handleFirebaseError(error);
     }
   }
+  /**
+   * 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) {
+    try {
+      console.log("[AUTH] Starting practitioner Google Sign-In/Sign-Up");
+      let email;
+      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;
+      } 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);
+      const methods = await (0, import_auth8.fetchSignInMethodsForEmail)(this.auth, normalizedEmail);
+      const hasGoogleMethod = methods.includes(import_auth8.GoogleAuthProvider.GOOGLE_SIGN_IN_METHOD);
+      const hasEmailMethod = methods.includes(import_auth8.EmailAuthProvider.EMAIL_PASSWORD_SIGN_IN_METHOD);
+      const practitionerService = new PractitionerService(this.db, this.auth, this.app);
+      if (hasGoogleMethod) {
+        console.log("[AUTH] User exists with Google provider, signing in");
+        const credential2 = import_auth8.GoogleAuthProvider.credential(idToken);
+        const { user: firebaseUser2 } = await (0, import_auth8.signInWithCredential)(this.auth, credential2);
+        const existingUser2 = await this.userService.getUserById(firebaseUser2.uid);
+        if (!existingUser2) {
+          await (0, import_auth8.signOut)(this.auth);
+          throw new AuthError(
+            "No account found. Please contact support.",
+            "AUTH/USER_NOT_FOUND",
+            404
+          );
+        }
+        let practitioner2 = null;
+        if (existingUser2.practitionerProfile) {
+          practitioner2 = await practitionerService.getPractitioner(existingUser2.practitionerProfile);
+        }
+        const draftProfiles2 = await practitionerService.getDraftProfilesByEmail(normalizedEmail);
+        return {
+          user: existingUser2,
+          practitioner: practitioner2,
+          draftProfiles: draftProfiles2
+        };
+      }
+      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
+        );
+      }
+      console.log("[AUTH] Signing in with Google credential");
+      const credential = import_auth8.GoogleAuthProvider.credential(idToken);
+      let firebaseUser;
+      try {
+        const result = await (0, import_auth8.signInWithCredential)(this.auth, credential);
+        firebaseUser = result.user;
+      } catch (error) {
+        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;
+      }
+      let existingUser = 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);
+      }
+      console.log("[AUTH] Checking for draft profiles");
+      const draftProfiles = await practitionerService.getDraftProfilesByEmail(normalizedEmail);
+      let user;
+      if (existingUser) {
+        user = existingUser;
+        console.log("[AUTH] Using existing user account");
+      } else {
+        user = await this.userService.createUser(firebaseUser, ["practitioner" /* PRACTITIONER */], {
+          skipProfileCreation: true
+        });
+        console.log("[AUTH] Created new user account");
+      }
+      let practitioner = 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