@blackcode_sa/metaestetics-api 1.13.6 → 1.13.10

package/dist/index.d.mts

@@ -6693,7 +6693,23 @@ declare class ProcedureService extends BaseService {
     private technologyService;
     private productService;
     private mediaService;
+    private practitionerService?;
     constructor(db: Firestore, auth: Auth, app: FirebaseApp, categoryService: CategoryService, subcategoryService: SubcategoryService, technologyService: TechnologyService, productService: ProductService, mediaService: MediaService);
+    setPractitionerService(practitionerService: PractitionerService): void;
+    /**
+     * Filters out procedures that should not be visible to patients:
+     * 1. Procedures with no practitioner (missing practitionerId)
+     * 2. Procedures where practitioner doesn't exist
+     * 3. Procedures from draft practitioners
+     * 4. Procedures from inactive practitioners (isActive === false)
+     *
+     * Note: Each procedure has ONE practitionerId. If that practitioner is inactive/draft/missing,
+     * the procedure is filtered out.
+     *
+     * @param procedures - Array of procedures to filter
+     * @returns Filtered array of procedures (excluding invalid/inactive/draft practitioners)
+     */
+    private filterDraftPractitionerProcedures;
     /**
      * Process media resource (string URL or File object)
      * @param media String URL or File object
@@ -6782,9 +6798,10 @@ declare class ProcedureService extends BaseService {
      * Gets all procedures for a practitioner
      * @param practitionerId - The ID of the practitioner
      * @param clinicBranchId - Optional clinic branch ID to filter by
+     * @param excludeDraftPractitioners - Whether to exclude procedures if the practitioner is in DRAFT status
      * @returns List of procedures
      */
-    getProceduresByPractitioner(practitionerId: string, clinicBranchId?: string): Promise<Procedure[]>;
+    getProceduresByPractitioner(practitionerId: string, clinicBranchId?: string, excludeDraftPractitioners?: boolean): Promise<Procedure[]>;
     /**
      * Gets all inactive procedures for a practitioner
      * @param practitionerId - The ID of the practitioner
@@ -6825,9 +6842,10 @@ declare class ProcedureService extends BaseService {
      *
      * @param pagination - Optional number of procedures per page (0 or undefined returns all)
      * @param lastDoc - Optional last document for pagination (if continuing from a previous page)
+     * @param excludeDraftPractitioners - Whether to exclude procedures from draft practitioners (default: true)
      * @returns Object containing procedures array and the last document for pagination
      */
-    getAllProcedures(pagination?: number, lastDoc?: any): Promise<{
+    getAllProcedures(pagination?: number, lastDoc?: any, excludeDraftPractitioners?: boolean): Promise<{
         procedures: Procedure[];
         lastDoc: any;
     }>;
@@ -6924,7 +6942,7 @@ declare class PractitionerService extends BaseService {
     private mediaService;
     private procedureService?;
     constructor(db: Firestore, auth: Auth, app: FirebaseApp, clinicService?: ClinicService, procedureService?: ProcedureService);
-    private getClinicService;
+    getClinicService(): ClinicService;
     private getProcedureService;
     setClinicService(clinicService: ClinicService): void;
     setProcedureService(procedureService: ProcedureService): void;
@@ -6992,6 +7010,19 @@ declare class PractitionerService extends BaseService {
      * Dohvata zdravstvenog radnika po User ID-u
      */
     getPractitionerByUserRef(userRef: string): Promise<Practitioner | null>;
+    /**
+     * Finds a draft practitioner profile by email address
+     * Used to detect if a draft profile exists when a doctor registers without a token
+     *
+     * @param email - Email address to search for
+     * @returns Draft practitioner profile if found, null otherwise
+     *
+     * @remarks
+     * Requires Firestore composite index on:
+     * - Collection: practitioners
+     * - Fields: basicInfo.email (Ascending), status (Ascending), userRef (Ascending)
+     */
+    findDraftPractitionerByEmail(email: string): Promise<Practitioner | null>;
     /**
      * Dohvata sve zdravstvene radnike za određenu kliniku sa statusom ACTIVE
      */

package/dist/index.d.ts

@@ -6693,7 +6693,23 @@ declare class ProcedureService extends BaseService {
     private technologyService;
     private productService;
     private mediaService;
+    private practitionerService?;
     constructor(db: Firestore, auth: Auth, app: FirebaseApp, categoryService: CategoryService, subcategoryService: SubcategoryService, technologyService: TechnologyService, productService: ProductService, mediaService: MediaService);
+    setPractitionerService(practitionerService: PractitionerService): void;
+    /**
+     * Filters out procedures that should not be visible to patients:
+     * 1. Procedures with no practitioner (missing practitionerId)
+     * 2. Procedures where practitioner doesn't exist
+     * 3. Procedures from draft practitioners
+     * 4. Procedures from inactive practitioners (isActive === false)
+     *
+     * Note: Each procedure has ONE practitionerId. If that practitioner is inactive/draft/missing,
+     * the procedure is filtered out.
+     *
+     * @param procedures - Array of procedures to filter
+     * @returns Filtered array of procedures (excluding invalid/inactive/draft practitioners)
+     */
+    private filterDraftPractitionerProcedures;
     /**
      * Process media resource (string URL or File object)
      * @param media String URL or File object
@@ -6782,9 +6798,10 @@ declare class ProcedureService extends BaseService {
      * Gets all procedures for a practitioner
      * @param practitionerId - The ID of the practitioner
      * @param clinicBranchId - Optional clinic branch ID to filter by
+     * @param excludeDraftPractitioners - Whether to exclude procedures if the practitioner is in DRAFT status
      * @returns List of procedures
      */
-    getProceduresByPractitioner(practitionerId: string, clinicBranchId?: string): Promise<Procedure[]>;
+    getProceduresByPractitioner(practitionerId: string, clinicBranchId?: string, excludeDraftPractitioners?: boolean): Promise<Procedure[]>;
     /**
      * Gets all inactive procedures for a practitioner
      * @param practitionerId - The ID of the practitioner
@@ -6825,9 +6842,10 @@ declare class ProcedureService extends BaseService {
      *
      * @param pagination - Optional number of procedures per page (0 or undefined returns all)
      * @param lastDoc - Optional last document for pagination (if continuing from a previous page)
+     * @param excludeDraftPractitioners - Whether to exclude procedures from draft practitioners (default: true)
      * @returns Object containing procedures array and the last document for pagination
      */
-    getAllProcedures(pagination?: number, lastDoc?: any): Promise<{
+    getAllProcedures(pagination?: number, lastDoc?: any, excludeDraftPractitioners?: boolean): Promise<{
         procedures: Procedure[];
         lastDoc: any;
     }>;
@@ -6924,7 +6942,7 @@ declare class PractitionerService extends BaseService {
     private mediaService;
     private procedureService?;
     constructor(db: Firestore, auth: Auth, app: FirebaseApp, clinicService?: ClinicService, procedureService?: ProcedureService);
-    private getClinicService;
+    getClinicService(): ClinicService;
     private getProcedureService;
     setClinicService(clinicService: ClinicService): void;
     setProcedureService(procedureService: ProcedureService): void;
@@ -6992,6 +7010,19 @@ declare class PractitionerService extends BaseService {
      * Dohvata zdravstvenog radnika po User ID-u
      */
     getPractitionerByUserRef(userRef: string): Promise<Practitioner | null>;
+    /**
+     * Finds a draft practitioner profile by email address
+     * Used to detect if a draft profile exists when a doctor registers without a token
+     *
+     * @param email - Email address to search for
+     * @returns Draft practitioner profile if found, null otherwise
+     *
+     * @remarks
+     * Requires Firestore composite index on:
+     * - Collection: practitioners
+     * - Fields: basicInfo.email (Ascending), status (Ascending), userRef (Ascending)
+     */
+    findDraftPractitionerByEmail(email: string): Promise<Practitioner | null>;
     /**
      * Dohvata sve zdravstvene radnike za određenu kliniku sa statusom ACTIVE
      */

package/dist/index.js

@@ -7319,11 +7319,12 @@ var userSchema = import_zod4.z.object({
 
 // src/errors/auth.errors.ts
 var AuthError = class extends Error {
-  constructor(message, code, status = 400) {
+  constructor(message, code, status = 400, metadata) {
     super(message);
     this.code = code;
     this.status = status;
     this.name = "AuthError";
+    this.metadata = metadata;
   }
 };
 var AUTH_ERRORS = {
@@ -7502,6 +7503,12 @@ var AUTH_ERRORS = {
     "Lozinka je previ\u0161e slaba. Molimo koristite ja\u010Du lozinku.",
     "AUTH/WEAK_PASSWORD",
     400
+  ),
+  // Draft profile exists error
+  DRAFT_PROFILE_EXISTS: new AuthError(
+    "A draft practitioner profile exists for this email. Please use your invitation code to claim it, or contact support if you don't have one.",
+    "AUTH/DRAFT_PROFILE_EXISTS",
+    409
   )
 };
 
@@ -11546,6 +11553,52 @@ var PractitionerService = class extends BaseService {
     }
     return querySnapshot.docs[0].data();
   }
+  /**
+   * Finds a draft practitioner profile by email address
+   * Used to detect if a draft profile exists when a doctor registers without a token
+   * 
+   * @param email - Email address to search for
+   * @returns Draft practitioner profile if found, null otherwise
+   * 
+   * @remarks
+   * Requires Firestore composite index on:
+   * - Collection: practitioners
+   * - Fields: basicInfo.email (Ascending), status (Ascending), userRef (Ascending)
+   */
+  async findDraftPractitionerByEmail(email) {
+    try {
+      const normalizedEmail = email.toLowerCase().trim();
+      console.log("[PRACTITIONER] Searching for draft practitioner 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", "==", ""),
+        (0, import_firestore32.limit)(1)
+      );
+      const querySnapshot = await (0, import_firestore32.getDocs)(q);
+      if (querySnapshot.empty) {
+        console.log("[PRACTITIONER] No draft practitioner found for email", {
+          email: normalizedEmail
+        });
+        return null;
+      }
+      const draftPractitioner = querySnapshot.docs[0].data();
+      console.log("[PRACTITIONER] Draft practitioner found", {
+        email: normalizedEmail,
+        practitionerId: draftPractitioner.id
+      });
+      return draftPractitioner;
+    } catch (error) {
+      console.error(
+        "[PRACTITIONER] Error finding draft practitioner by email:",
+        error
+      );
+      return null;
+    }
+  }
   /**
    * Dohvata sve zdravstvene radnike za određenu kliniku sa statusom ACTIVE
    */
@@ -15290,7 +15343,49 @@ var AuthService = class extends BaseService {
           }
           practitioner = claimedPractitioner;
         } else {
-          console.log("[AUTH] Creating new practitioner profile");
+          console.log("[AUTH] Checking for existing draft practitioner profile", {
+            email: data.email
+          });
+          const draftPractitioner = await practitionerService.findDraftPractitionerByEmail(
+            data.email
+          );
+          if (draftPractitioner) {
+            console.log("[AUTH] Draft practitioner profile found", {
+              practitionerId: draftPractitioner.id,
+              email: data.email,
+              clinics: draftPractitioner.clinics
+            });
+            let clinicNames = [];
+            if (draftPractitioner.clinicsInfo && draftPractitioner.clinicsInfo.length > 0) {
+              clinicNames = draftPractitioner.clinicsInfo.map((clinic) => clinic.name).filter((name) => !!name);
+            } else if (draftPractitioner.clinics && draftPractitioner.clinics.length > 0) {
+              console.log("[AUTH] clinicsInfo missing, fetching clinic names from clinic IDs");
+              const clinicService = practitionerService.getClinicService();
+              const clinicNamePromises = draftPractitioner.clinics.map(async (clinicId) => {
+                try {
+                  const clinic = await clinicService.getClinic(clinicId);
+                  return (clinic == null ? void 0 : clinic.name) || null;
+                } catch (error) {
+                  console.error(`[AUTH] Error fetching clinic ${clinicId}:`, error);
+                  return null;
+                }
+              });
+              const names = await Promise.all(clinicNamePromises);
+              clinicNames = names.filter((name) => !!name);
+            }
+            await cleanupFirebaseUser(firebaseUser);
+            throw new AuthError(
+              AUTH_ERRORS.DRAFT_PROFILE_EXISTS.message,
+              AUTH_ERRORS.DRAFT_PROFILE_EXISTS.code,
+              AUTH_ERRORS.DRAFT_PROFILE_EXISTS.status,
+              {
+                clinicNames,
+                clinics: draftPractitioner.clinics,
+                clinicsInfo: draftPractitioner.clinicsInfo
+              }
+            );
+          }
+          console.log("[AUTH] No draft profile found, creating new practitioner profile");
           const practitionerData = buildPractitionerData(data, firebaseUser.uid);
           practitioner = await practitionerService.createPractitioner(practitionerData);
         }
@@ -19923,6 +20018,91 @@ var ProcedureService = class extends BaseService {
     this.productService = productService;
     this.mediaService = mediaService;
   }
+  setPractitionerService(practitionerService) {
+    this.practitionerService = practitionerService;
+  }
+  /**
+   * Filters out procedures that should not be visible to patients:
+   * 1. Procedures with no practitioner (missing practitionerId)
+   * 2. Procedures where practitioner doesn't exist
+   * 3. Procedures from draft practitioners
+   * 4. Procedures from inactive practitioners (isActive === false)
+   * 
+   * Note: Each procedure has ONE practitionerId. If that practitioner is inactive/draft/missing,
+   * the procedure is filtered out.
+   * 
+   * @param procedures - Array of procedures to filter
+   * @returns Filtered array of procedures (excluding invalid/inactive/draft practitioners)
+   */
+  async filterDraftPractitionerProcedures(procedures) {
+    if (!this.practitionerService || procedures.length === 0) {
+      return procedures;
+    }
+    try {
+      const proceduresWithPractitioner = procedures.filter(
+        (p) => p.practitionerId && p.practitionerId.trim() !== ""
+      );
+      if (proceduresWithPractitioner.length === 0) {
+        console.log(
+          `[ProcedureService] All ${procedures.length} procedures have no practitionerId - filtering out`
+        );
+        return [];
+      }
+      const practitionerIds = Array.from(
+        new Set(proceduresWithPractitioner.map((p) => p.practitionerId).filter(Boolean))
+      );
+      if (practitionerIds.length === 0) {
+        return [];
+      }
+      const practitionerPromises = practitionerIds.map(
+        (id) => this.practitionerService.getPractitioner(id).catch(() => null)
+      );
+      const practitioners = await Promise.all(practitionerPromises);
+      const practitionerMap = /* @__PURE__ */ new Map();
+      practitioners.forEach((practitioner, index) => {
+        if (practitioner) {
+          practitionerMap.set(practitionerIds[index], practitioner);
+        }
+      });
+      const filteredProcedures = proceduresWithPractitioner.filter((procedure) => {
+        const practitioner = practitionerMap.get(procedure.practitionerId);
+        if (!practitioner) {
+          console.log(
+            `[ProcedureService] Filtering out procedure ${procedure.id} - practitioner ${procedure.practitionerId} not found`
+          );
+          return false;
+        }
+        if (practitioner.status === "draft" /* DRAFT */) {
+          console.log(
+            `[ProcedureService] Filtering out procedure ${procedure.id} - practitioner ${procedure.practitionerId} is DRAFT`
+          );
+          return false;
+        }
+        if (!practitioner.isActive) {
+          console.log(
+            `[ProcedureService] Filtering out procedure ${procedure.id} - practitioner ${procedure.practitionerId} is not active`
+          );
+          return false;
+        }
+        return true;
+      });
+      const filteredCount = procedures.length - filteredProcedures.length;
+      if (filteredCount > 0) {
+        const noPractitionerCount = procedures.length - proceduresWithPractitioner.length;
+        const invalidPractitionerCount = proceduresWithPractitioner.length - filteredProcedures.length;
+        console.log(
+          `[ProcedureService] Filtered out ${filteredCount} procedures: ${noPractitionerCount} with no practitionerId, ${invalidPractitionerCount} with missing/draft/inactive practitioners`
+        );
+      }
+      return filteredProcedures;
+    } catch (error) {
+      console.error(
+        "[ProcedureService] Error filtering practitioner procedures:",
+        error
+      );
+      return procedures;
+    }
+  }
   /**
    * Process media resource (string URL or File object)
    * @param media String URL or File object
@@ -20627,15 +20807,17 @@ var ProcedureService = class extends BaseService {
       (0, import_firestore58.where)("isActive", "==", true)
     );
     const snapshot = await (0, import_firestore58.getDocs)(q);
-    return snapshot.docs.map((doc47) => doc47.data());
+    const procedures = snapshot.docs.map((doc47) => doc47.data());
+    return await this.filterDraftPractitionerProcedures(procedures);
   }
   /**
    * Gets all procedures for a practitioner
    * @param practitionerId - The ID of the practitioner
    * @param clinicBranchId - Optional clinic branch ID to filter by
+   * @param excludeDraftPractitioners - Whether to exclude procedures if the practitioner is in DRAFT status
    * @returns List of procedures
    */
-  async getProceduresByPractitioner(practitionerId, clinicBranchId) {
+  async getProceduresByPractitioner(practitionerId, clinicBranchId, excludeDraftPractitioners = true) {
     const constraints = [
       (0, import_firestore58.where)("practitionerId", "==", practitionerId),
       (0, import_firestore58.where)("isActive", "==", true)
@@ -20648,7 +20830,19 @@ var ProcedureService = class extends BaseService {
       ...constraints
     );
     const snapshot = await (0, import_firestore58.getDocs)(q);
-    return snapshot.docs.map((doc47) => doc47.data());
+    const procedures = snapshot.docs.map((doc47) => doc47.data());
+    if (excludeDraftPractitioners && this.practitionerService) {
+      try {
+        const practitioner = await this.practitionerService.getPractitioner(practitionerId);
+        if (practitioner && practitioner.status === "draft" /* DRAFT */) {
+          console.log(`[ProcedureService] Excluding procedures for draft practitioner ${practitionerId}`);
+          return [];
+        }
+      } catch (error) {
+        console.error(`[ProcedureService] Error checking practitioner status for ${practitionerId}:`, error);
+      }
+    }
+    return procedures;
   }
   /**
    * Gets all inactive procedures for a practitioner
@@ -20857,9 +21051,10 @@ var ProcedureService = class extends BaseService {
    *
    * @param pagination - Optional number of procedures per page (0 or undefined returns all)
    * @param lastDoc - Optional last document for pagination (if continuing from a previous page)
+   * @param excludeDraftPractitioners - Whether to exclude procedures from draft practitioners (default: true)
    * @returns Object containing procedures array and the last document for pagination
    */
-  async getAllProcedures(pagination, lastDoc) {
+  async getAllProcedures(pagination, lastDoc, excludeDraftPractitioners = true) {
     try {
       const proceduresCollection = (0, import_firestore58.collection)(this.db, PROCEDURES_COLLECTION);
       let proceduresQuery = (0, import_firestore58.query)(proceduresCollection);
@@ -20881,7 +21076,7 @@ var ProcedureService = class extends BaseService {
       }
       const proceduresSnapshot = await (0, import_firestore58.getDocs)(proceduresQuery);
       const lastVisible = proceduresSnapshot.docs[proceduresSnapshot.docs.length - 1];
-      const procedures = proceduresSnapshot.docs.map((doc47) => {
+      let procedures = proceduresSnapshot.docs.map((doc47) => {
         const data = doc47.data();
         return {
           ...data,
@@ -20889,6 +21084,9 @@ var ProcedureService = class extends BaseService {
           // Ensure ID is present
         };
       });
+      if (excludeDraftPractitioners) {
+        procedures = await this.filterDraftPractitionerProcedures(procedures);
+      }
       return {
         procedures,
         lastDoc: lastVisible
@@ -21013,6 +21211,7 @@ var ProcedureService = class extends BaseService {
           if (hasNestedFilters) {
             procedures = this.applyInMemoryFilters(procedures, filters);
           }
+          procedures = await this.filterDraftPractitionerProcedures(procedures);
           const lastDoc = querySnapshot.docs.length > 0 ? querySnapshot.docs[querySnapshot.docs.length - 1] : null;
           console.log(`[PROCEDURE_SERVICE] Strategy 1 success: ${procedures.length} procedures`);
           if (procedures.length < (filters.pagination || 10)) {
@@ -21053,6 +21252,7 @@ var ProcedureService = class extends BaseService {
           if (hasNestedFilters) {
             procedures = this.applyInMemoryFilters(procedures, filters);
           }
+          procedures = await this.filterDraftPractitionerProcedures(procedures);
           const lastDoc = querySnapshot.docs.length > 0 ? querySnapshot.docs[querySnapshot.docs.length - 1] : null;
           console.log(`[PROCEDURE_SERVICE] Strategy 2 success: ${procedures.length} procedures`);
           if (procedures.length < (filters.pagination || 10)) {
@@ -21133,6 +21333,7 @@ var ProcedureService = class extends BaseService {
           }
         });
         procedures = this.applyInMemoryFilters(procedures, filters);
+        procedures = await this.filterDraftPractitionerProcedures(procedures);
         console.log("[PROCEDURE_SERVICE] After applyInMemoryFilters (Strategy 3):", {
           procedureCount: procedures.length
         });
@@ -21164,6 +21365,7 @@ var ProcedureService = class extends BaseService {
           (doc47) => ({ ...doc47.data(), id: doc47.id })
         );
         procedures = this.applyInMemoryFilters(procedures, filters);
+        procedures = await this.filterDraftPractitionerProcedures(procedures);
         const lastDoc = querySnapshot.docs.length > 0 ? querySnapshot.docs[querySnapshot.docs.length - 1] : null;
         console.log(`[PROCEDURE_SERVICE] Strategy 4 success: ${procedures.length} procedures`);
         if (procedures.length < (filters.pagination || 10)) {

package/dist/index.mjs

@@ -7225,11 +7225,12 @@ var userSchema = z4.object({
 
 // src/errors/auth.errors.ts
 var AuthError = class extends Error {
-  constructor(message, code, status = 400) {
+  constructor(message, code, status = 400, metadata) {
     super(message);
     this.code = code;
     this.status = status;
     this.name = "AuthError";
+    this.metadata = metadata;
   }
 };
 var AUTH_ERRORS = {
@@ -7408,6 +7409,12 @@ var AUTH_ERRORS = {
     "Lozinka je previ\u0161e slaba. Molimo koristite ja\u010Du lozinku.",
     "AUTH/WEAK_PASSWORD",
     400
+  ),
+  // Draft profile exists error
+  DRAFT_PROFILE_EXISTS: new AuthError(
+    "A draft practitioner profile exists for this email. Please use your invitation code to claim it, or contact support if you don't have one.",
+    "AUTH/DRAFT_PROFILE_EXISTS",
+    409
   )
 };
 
@@ -11569,6 +11576,52 @@ var PractitionerService = class extends BaseService {
     }
     return querySnapshot.docs[0].data();
   }
+  /**
+   * Finds a draft practitioner profile by email address
+   * Used to detect if a draft profile exists when a doctor registers without a token
+   * 
+   * @param email - Email address to search for
+   * @returns Draft practitioner profile if found, null otherwise
+   * 
+   * @remarks
+   * Requires Firestore composite index on:
+   * - Collection: practitioners
+   * - Fields: basicInfo.email (Ascending), status (Ascending), userRef (Ascending)
+   */
+  async findDraftPractitionerByEmail(email) {
+    try {
+      const normalizedEmail = email.toLowerCase().trim();
+      console.log("[PRACTITIONER] Searching for draft practitioner by email", {
+        email: normalizedEmail
+      });
+      const q = query13(
+        collection13(this.db, PRACTITIONERS_COLLECTION),
+        where13("basicInfo.email", "==", normalizedEmail),
+        where13("status", "==", "draft" /* DRAFT */),
+        where13("userRef", "==", ""),
+        limit7(1)
+      );
+      const querySnapshot = await getDocs13(q);
+      if (querySnapshot.empty) {
+        console.log("[PRACTITIONER] No draft practitioner found for email", {
+          email: normalizedEmail
+        });
+        return null;
+      }
+      const draftPractitioner = querySnapshot.docs[0].data();
+      console.log("[PRACTITIONER] Draft practitioner found", {
+        email: normalizedEmail,
+        practitionerId: draftPractitioner.id
+      });
+      return draftPractitioner;
+    } catch (error) {
+      console.error(
+        "[PRACTITIONER] Error finding draft practitioner by email:",
+        error
+      );
+      return null;
+    }
+  }
   /**
    * Dohvata sve zdravstvene radnike za određenu kliniku sa statusom ACTIVE
    */
@@ -15377,7 +15430,49 @@ var AuthService = class extends BaseService {
           }
           practitioner = claimedPractitioner;
         } else {
-          console.log("[AUTH] Creating new practitioner profile");
+          console.log("[AUTH] Checking for existing draft practitioner profile", {
+            email: data.email
+          });
+          const draftPractitioner = await practitionerService.findDraftPractitionerByEmail(
+            data.email
+          );
+          if (draftPractitioner) {
+            console.log("[AUTH] Draft practitioner profile found", {
+              practitionerId: draftPractitioner.id,
+              email: data.email,
+              clinics: draftPractitioner.clinics
+            });
+            let clinicNames = [];
+            if (draftPractitioner.clinicsInfo && draftPractitioner.clinicsInfo.length > 0) {
+              clinicNames = draftPractitioner.clinicsInfo.map((clinic) => clinic.name).filter((name) => !!name);
+            } else if (draftPractitioner.clinics && draftPractitioner.clinics.length > 0) {
+              console.log("[AUTH] clinicsInfo missing, fetching clinic names from clinic IDs");
+              const clinicService = practitionerService.getClinicService();
+              const clinicNamePromises = draftPractitioner.clinics.map(async (clinicId) => {
+                try {
+                  const clinic = await clinicService.getClinic(clinicId);
+                  return (clinic == null ? void 0 : clinic.name) || null;
+                } catch (error) {
+                  console.error(`[AUTH] Error fetching clinic ${clinicId}:`, error);
+                  return null;
+                }
+              });
+              const names = await Promise.all(clinicNamePromises);
+              clinicNames = names.filter((name) => !!name);
+            }
+            await cleanupFirebaseUser(firebaseUser);
+            throw new AuthError(
+              AUTH_ERRORS.DRAFT_PROFILE_EXISTS.message,
+              AUTH_ERRORS.DRAFT_PROFILE_EXISTS.code,
+              AUTH_ERRORS.DRAFT_PROFILE_EXISTS.status,
+              {
+                clinicNames,
+                clinics: draftPractitioner.clinics,
+                clinicsInfo: draftPractitioner.clinicsInfo
+              }
+            );
+          }
+          console.log("[AUTH] No draft profile found, creating new practitioner profile");
           const practitionerData = buildPractitionerData(data, firebaseUser.uid);
           practitioner = await practitionerService.createPractitioner(practitionerData);
         }
@@ -20159,6 +20254,91 @@ var ProcedureService = class extends BaseService {
     this.productService = productService;
     this.mediaService = mediaService;
   }
+  setPractitionerService(practitionerService) {
+    this.practitionerService = practitionerService;
+  }
+  /**
+   * Filters out procedures that should not be visible to patients:
+   * 1. Procedures with no practitioner (missing practitionerId)
+   * 2. Procedures where practitioner doesn't exist
+   * 3. Procedures from draft practitioners
+   * 4. Procedures from inactive practitioners (isActive === false)
+   * 
+   * Note: Each procedure has ONE practitionerId. If that practitioner is inactive/draft/missing,
+   * the procedure is filtered out.
+   * 
+   * @param procedures - Array of procedures to filter
+   * @returns Filtered array of procedures (excluding invalid/inactive/draft practitioners)
+   */
+  async filterDraftPractitionerProcedures(procedures) {
+    if (!this.practitionerService || procedures.length === 0) {
+      return procedures;
+    }
+    try {
+      const proceduresWithPractitioner = procedures.filter(
+        (p) => p.practitionerId && p.practitionerId.trim() !== ""
+      );
+      if (proceduresWithPractitioner.length === 0) {
+        console.log(
+          `[ProcedureService] All ${procedures.length} procedures have no practitionerId - filtering out`
+        );
+        return [];
+      }
+      const practitionerIds = Array.from(
+        new Set(proceduresWithPractitioner.map((p) => p.practitionerId).filter(Boolean))
+      );
+      if (practitionerIds.length === 0) {
+        return [];
+      }
+      const practitionerPromises = practitionerIds.map(
+        (id) => this.practitionerService.getPractitioner(id).catch(() => null)
+      );
+      const practitioners = await Promise.all(practitionerPromises);
+      const practitionerMap = /* @__PURE__ */ new Map();
+      practitioners.forEach((practitioner, index) => {
+        if (practitioner) {
+          practitionerMap.set(practitionerIds[index], practitioner);
+        }
+      });
+      const filteredProcedures = proceduresWithPractitioner.filter((procedure) => {
+        const practitioner = practitionerMap.get(procedure.practitionerId);
+        if (!practitioner) {
+          console.log(
+            `[ProcedureService] Filtering out procedure ${procedure.id} - practitioner ${procedure.practitionerId} not found`
+          );
+          return false;
+        }
+        if (practitioner.status === "draft" /* DRAFT */) {
+          console.log(
+            `[ProcedureService] Filtering out procedure ${procedure.id} - practitioner ${procedure.practitionerId} is DRAFT`
+          );
+          return false;
+        }
+        if (!practitioner.isActive) {
+          console.log(
+            `[ProcedureService] Filtering out procedure ${procedure.id} - practitioner ${procedure.practitionerId} is not active`
+          );
+          return false;
+        }
+        return true;
+      });
+      const filteredCount = procedures.length - filteredProcedures.length;
+      if (filteredCount > 0) {
+        const noPractitionerCount = procedures.length - proceduresWithPractitioner.length;
+        const invalidPractitionerCount = proceduresWithPractitioner.length - filteredProcedures.length;
+        console.log(
+          `[ProcedureService] Filtered out ${filteredCount} procedures: ${noPractitionerCount} with no practitionerId, ${invalidPractitionerCount} with missing/draft/inactive practitioners`
+        );
+      }
+      return filteredProcedures;
+    } catch (error) {
+      console.error(
+        "[ProcedureService] Error filtering practitioner procedures:",
+        error
+      );
+      return procedures;
+    }
+  }
   /**
    * Process media resource (string URL or File object)
    * @param media String URL or File object
@@ -20863,15 +21043,17 @@ var ProcedureService = class extends BaseService {
       where33("isActive", "==", true)
     );
     const snapshot = await getDocs33(q);
-    return snapshot.docs.map((doc47) => doc47.data());
+    const procedures = snapshot.docs.map((doc47) => doc47.data());
+    return await this.filterDraftPractitionerProcedures(procedures);
   }
   /**
    * Gets all procedures for a practitioner
    * @param practitionerId - The ID of the practitioner
    * @param clinicBranchId - Optional clinic branch ID to filter by
+   * @param excludeDraftPractitioners - Whether to exclude procedures if the practitioner is in DRAFT status
    * @returns List of procedures
    */
-  async getProceduresByPractitioner(practitionerId, clinicBranchId) {
+  async getProceduresByPractitioner(practitionerId, clinicBranchId, excludeDraftPractitioners = true) {
     const constraints = [
       where33("practitionerId", "==", practitionerId),
       where33("isActive", "==", true)
@@ -20884,7 +21066,19 @@ var ProcedureService = class extends BaseService {
       ...constraints
     );
     const snapshot = await getDocs33(q);
-    return snapshot.docs.map((doc47) => doc47.data());
+    const procedures = snapshot.docs.map((doc47) => doc47.data());
+    if (excludeDraftPractitioners && this.practitionerService) {
+      try {
+        const practitioner = await this.practitionerService.getPractitioner(practitionerId);
+        if (practitioner && practitioner.status === "draft" /* DRAFT */) {
+          console.log(`[ProcedureService] Excluding procedures for draft practitioner ${practitionerId}`);
+          return [];
+        }
+      } catch (error) {
+        console.error(`[ProcedureService] Error checking practitioner status for ${practitionerId}:`, error);
+      }
+    }
+    return procedures;
   }
   /**
    * Gets all inactive procedures for a practitioner
@@ -21093,9 +21287,10 @@ var ProcedureService = class extends BaseService {
    *
    * @param pagination - Optional number of procedures per page (0 or undefined returns all)
    * @param lastDoc - Optional last document for pagination (if continuing from a previous page)
+   * @param excludeDraftPractitioners - Whether to exclude procedures from draft practitioners (default: true)
    * @returns Object containing procedures array and the last document for pagination
    */
-  async getAllProcedures(pagination, lastDoc) {
+  async getAllProcedures(pagination, lastDoc, excludeDraftPractitioners = true) {
     try {
       const proceduresCollection = collection33(this.db, PROCEDURES_COLLECTION);
       let proceduresQuery = query33(proceduresCollection);
@@ -21117,7 +21312,7 @@ var ProcedureService = class extends BaseService {
       }
       const proceduresSnapshot = await getDocs33(proceduresQuery);
       const lastVisible = proceduresSnapshot.docs[proceduresSnapshot.docs.length - 1];
-      const procedures = proceduresSnapshot.docs.map((doc47) => {
+      let procedures = proceduresSnapshot.docs.map((doc47) => {
         const data = doc47.data();
         return {
           ...data,
@@ -21125,6 +21320,9 @@ var ProcedureService = class extends BaseService {
           // Ensure ID is present
         };
       });
+      if (excludeDraftPractitioners) {
+        procedures = await this.filterDraftPractitionerProcedures(procedures);
+      }
       return {
         procedures,
         lastDoc: lastVisible
@@ -21249,6 +21447,7 @@ var ProcedureService = class extends BaseService {
           if (hasNestedFilters) {
             procedures = this.applyInMemoryFilters(procedures, filters);
           }
+          procedures = await this.filterDraftPractitionerProcedures(procedures);
           const lastDoc = querySnapshot.docs.length > 0 ? querySnapshot.docs[querySnapshot.docs.length - 1] : null;
           console.log(`[PROCEDURE_SERVICE] Strategy 1 success: ${procedures.length} procedures`);
           if (procedures.length < (filters.pagination || 10)) {
@@ -21289,6 +21488,7 @@ var ProcedureService = class extends BaseService {
           if (hasNestedFilters) {
             procedures = this.applyInMemoryFilters(procedures, filters);
           }
+          procedures = await this.filterDraftPractitionerProcedures(procedures);
           const lastDoc = querySnapshot.docs.length > 0 ? querySnapshot.docs[querySnapshot.docs.length - 1] : null;
           console.log(`[PROCEDURE_SERVICE] Strategy 2 success: ${procedures.length} procedures`);
           if (procedures.length < (filters.pagination || 10)) {
@@ -21369,6 +21569,7 @@ var ProcedureService = class extends BaseService {
           }
         });
         procedures = this.applyInMemoryFilters(procedures, filters);
+        procedures = await this.filterDraftPractitionerProcedures(procedures);
         console.log("[PROCEDURE_SERVICE] After applyInMemoryFilters (Strategy 3):", {
           procedureCount: procedures.length
         });
@@ -21400,6 +21601,7 @@ var ProcedureService = class extends BaseService {
           (doc47) => ({ ...doc47.data(), id: doc47.id })
         );
         procedures = this.applyInMemoryFilters(procedures, filters);
+        procedures = await this.filterDraftPractitionerProcedures(procedures);
         const lastDoc = querySnapshot.docs.length > 0 ? querySnapshot.docs[querySnapshot.docs.length - 1] : null;
         console.log(`[PROCEDURE_SERVICE] Strategy 4 success: ${procedures.length} procedures`);
         if (procedures.length < (filters.pagination || 10)) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@blackcode_sa/metaestetics-api",
   "private": false,
-  "version": "1.13.6",
+  "version": "1.13.10",
   "description": "Firebase authentication service with anonymous upgrade support",
   "main": "dist/index.js",
   "module": "dist/index.mjs",

package/src/errors/auth.errors.ts

@@ -1,11 +1,15 @@
 export class AuthError extends Error {
+  public metadata?: Record<string, any>;
+
   constructor(
     message: string,
     public code: string,
-    public status: number = 400
+    public status: number = 400,
+    metadata?: Record<string, any>
   ) {
     super(message);
     this.name = "AuthError";
+    this.metadata = metadata;
   }
 }
 
@@ -197,4 +201,11 @@ export const AUTH_ERRORS = {
     "AUTH/WEAK_PASSWORD",
     400
   ),
+
+  // Draft profile exists error
+  DRAFT_PROFILE_EXISTS: new AuthError(
+    "A draft practitioner profile exists for this email. Please use your invitation code to claim it, or contact support if you don't have one.",
+    "AUTH/DRAFT_PROFILE_EXISTS",
+    409
+  ),
 } as const;

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

@@ -724,7 +724,61 @@ export class AuthService extends BaseService {
           }
           practitioner = claimedPractitioner;
         } else {
-          console.log('[AUTH] Creating new practitioner profile');
+          // Check if a draft profile exists for this email
+          console.log('[AUTH] Checking for existing draft practitioner profile', {
+            email: data.email,
+          });
+          const draftPractitioner = await practitionerService.findDraftPractitionerByEmail(
+            data.email
+          );
+
+          if (draftPractitioner) {
+            console.log('[AUTH] Draft practitioner profile found', {
+              practitionerId: draftPractitioner.id,
+              email: data.email,
+              clinics: draftPractitioner.clinics,
+            });
+            
+            // Extract clinic names from clinicsInfo (should be populated when draft is created)
+            let clinicNames: string[] = [];
+            if (draftPractitioner.clinicsInfo && draftPractitioner.clinicsInfo.length > 0) {
+              clinicNames = draftPractitioner.clinicsInfo
+                .map((clinic) => clinic.name)
+                .filter((name): name is string => !!name);
+            } else if (draftPractitioner.clinics && draftPractitioner.clinics.length > 0) {
+              // Fallback: fetch clinic names if clinicsInfo is missing
+              console.log('[AUTH] clinicsInfo missing, fetching clinic names from clinic IDs');
+              const clinicService = practitionerService.getClinicService();
+              const clinicNamePromises = draftPractitioner.clinics.map(async (clinicId) => {
+                try {
+                  const clinic = await clinicService.getClinic(clinicId);
+                  return clinic?.name || null;
+                } catch (error) {
+                  console.error(`[AUTH] Error fetching clinic ${clinicId}:`, error);
+                  return null;
+                }
+              });
+              const names = await Promise.all(clinicNamePromises);
+              clinicNames = names.filter((name): name is string => !!name);
+            }
+            
+            // Cleanup Firebase user since we're not creating a profile
+            await cleanupFirebaseUser(firebaseUser);
+            
+            // Throw error with clinic information
+            throw new AuthError(
+              AUTH_ERRORS.DRAFT_PROFILE_EXISTS.message,
+              AUTH_ERRORS.DRAFT_PROFILE_EXISTS.code,
+              AUTH_ERRORS.DRAFT_PROFILE_EXISTS.status,
+              {
+                clinicNames,
+                clinics: draftPractitioner.clinics,
+                clinicsInfo: draftPractitioner.clinicsInfo,
+              }
+            );
+          }
+
+          console.log('[AUTH] No draft profile found, creating new practitioner profile');
           const practitionerData = buildPractitionerData(data, firebaseUser.uid);
           practitioner = await practitionerService.createPractitioner(practitionerData);
         }

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

@@ -81,7 +81,7 @@ export class PractitionerService extends BaseService {
     this.mediaService = new MediaService(db, auth, app);
   }
 
-  private getClinicService(): ClinicService {
+  public getClinicService(): ClinicService {
     if (!this.clinicService) {
       throw new Error("Clinic service not initialized!");
     }
@@ -657,6 +657,63 @@ export class PractitionerService extends BaseService {
     return querySnapshot.docs[0].data() as Practitioner;
   }
 
+  /**
+   * Finds a draft practitioner profile by email address
+   * Used to detect if a draft profile exists when a doctor registers without a token
+   * 
+   * @param email - Email address to search for
+   * @returns Draft practitioner profile if found, null otherwise
+   * 
+   * @remarks
+   * Requires Firestore composite index on:
+   * - Collection: practitioners
+   * - Fields: basicInfo.email (Ascending), status (Ascending), userRef (Ascending)
+   */
+  async findDraftPractitionerByEmail(
+    email: string
+  ): Promise<Practitioner | null> {
+    try {
+      const normalizedEmail = email.toLowerCase().trim();
+      
+      console.log("[PRACTITIONER] Searching for draft practitioner by email", {
+        email: normalizedEmail,
+      });
+
+      const q = query(
+        collection(this.db, PRACTITIONERS_COLLECTION),
+        where("basicInfo.email", "==", normalizedEmail),
+        where("status", "==", PractitionerStatus.DRAFT),
+        where("userRef", "==", ""),
+        limit(1)
+      );
+
+      const querySnapshot = await getDocs(q);
+      
+      if (querySnapshot.empty) {
+        console.log("[PRACTITIONER] No draft practitioner found for email", {
+          email: normalizedEmail,
+        });
+        return null;
+      }
+
+      const draftPractitioner = querySnapshot.docs[0].data() as Practitioner;
+      console.log("[PRACTITIONER] Draft practitioner found", {
+        email: normalizedEmail,
+        practitionerId: draftPractitioner.id,
+      });
+
+      return draftPractitioner;
+    } catch (error) {
+      console.error(
+        "[PRACTITIONER] Error finding draft practitioner by email:",
+        error
+      );
+      // If query fails (e.g., index not created), return null to allow registration
+      // This prevents blocking registration if index is missing
+      return null;
+    }
+  }
+
   /**
    * Dohvata sve zdravstvene radnike za određenu kliniku sa statusom ACTIVE
    */

package/src/services/procedure/procedure.service.ts

@@ -56,12 +56,16 @@ import { distanceBetween, geohashQueryBounds } from 'geofire-common';
 import { MediaService, MediaAccessLevel } from '../media/media.service';
 import type { ProcedureProduct } from '../../backoffice/types/procedure-product.types';
 
+import { PractitionerService } from '../practitioner/practitioner.service';
+import { PractitionerStatus } from '../../types/practitioner';
+
 export class ProcedureService extends BaseService {
   private categoryService: CategoryService;
   private subcategoryService: SubcategoryService;
   private technologyService: TechnologyService;
   private productService: ProductService;
   private mediaService: MediaService;
+  private practitionerService?: PractitionerService;
 
   constructor(
     db: Firestore,
@@ -81,6 +85,123 @@ export class ProcedureService extends BaseService {
     this.mediaService = mediaService;
   }
 
+  setPractitionerService(practitionerService: PractitionerService) {
+    this.practitionerService = practitionerService;
+  }
+
+  /**
+   * Filters out procedures that should not be visible to patients:
+   * 1. Procedures with no practitioner (missing practitionerId)
+   * 2. Procedures where practitioner doesn't exist
+   * 3. Procedures from draft practitioners
+   * 4. Procedures from inactive practitioners (isActive === false)
+   * 
+   * Note: Each procedure has ONE practitionerId. If that practitioner is inactive/draft/missing,
+   * the procedure is filtered out.
+   * 
+   * @param procedures - Array of procedures to filter
+   * @returns Filtered array of procedures (excluding invalid/inactive/draft practitioners)
+   */
+  private async filterDraftPractitionerProcedures(
+    procedures: Procedure[]
+  ): Promise<Procedure[]> {
+    if (!this.practitionerService || procedures.length === 0) {
+      return procedures;
+    }
+
+    try {
+      // First, filter out procedures with no practitionerId
+      const proceduresWithPractitioner = procedures.filter((p) => 
+        p.practitionerId && p.practitionerId.trim() !== ''
+      );
+
+      if (proceduresWithPractitioner.length === 0) {
+        console.log(
+          `[ProcedureService] All ${procedures.length} procedures have no practitionerId - filtering out`
+        );
+        return [];
+      }
+
+      // Get unique practitioner IDs from procedures
+      const practitionerIds = Array.from(
+        new Set(proceduresWithPractitioner.map((p) => p.practitionerId).filter(Boolean))
+      );
+
+      if (practitionerIds.length === 0) {
+        return [];
+      }
+
+      // Fetch all practitioners in parallel
+      const practitionerPromises = practitionerIds.map((id) =>
+        this.practitionerService!.getPractitioner(id).catch(() => null)
+      );
+      const practitioners = await Promise.all(practitionerPromises);
+
+      // Create a map of practitioner ID to practitioner data
+      const practitionerMap = new Map<string, Practitioner>();
+      practitioners.forEach((practitioner, index) => {
+        if (practitioner) {
+          practitionerMap.set(practitionerIds[index], practitioner);
+        }
+      });
+
+      // Filter out procedures that:
+      // 1. Have no practitionerId (already filtered above, but double-check)
+      // 2. Have a practitioner that doesn't exist
+      // 3. Have a practitioner with DRAFT status
+      // 4. Have a practitioner that is not active (isActive === false)
+      const filteredProcedures = proceduresWithPractitioner.filter((procedure) => {
+        // Check if practitioner exists
+        const practitioner = practitionerMap.get(procedure.practitionerId);
+        
+        if (!practitioner) {
+          console.log(
+            `[ProcedureService] Filtering out procedure ${procedure.id} - practitioner ${procedure.practitionerId} not found`
+          );
+          return false;
+        }
+
+        // Check if practitioner is DRAFT
+        if (practitioner.status === PractitionerStatus.DRAFT) {
+          console.log(
+            `[ProcedureService] Filtering out procedure ${procedure.id} - practitioner ${procedure.practitionerId} is DRAFT`
+          );
+          return false;
+        }
+
+        // Check if practitioner is active (must be true to show procedure)
+        if (!practitioner.isActive) {
+          console.log(
+            `[ProcedureService] Filtering out procedure ${procedure.id} - practitioner ${procedure.practitionerId} is not active`
+          );
+          return false;
+        }
+
+        return true;
+      });
+
+      const filteredCount = procedures.length - filteredProcedures.length;
+      if (filteredCount > 0) {
+        const noPractitionerCount = procedures.length - proceduresWithPractitioner.length;
+        const invalidPractitionerCount = proceduresWithPractitioner.length - filteredProcedures.length;
+        console.log(
+          `[ProcedureService] Filtered out ${filteredCount} procedures: ` +
+          `${noPractitionerCount} with no practitionerId, ` +
+          `${invalidPractitionerCount} with missing/draft/inactive practitioners`
+        );
+      }
+
+      return filteredProcedures;
+    } catch (error) {
+      console.error(
+        '[ProcedureService] Error filtering practitioner procedures:',
+        error
+      );
+      // On error, return original procedures to avoid breaking functionality
+      return procedures;
+    }
+  }
+
   /**
    * Process media resource (string URL or File object)
    * @param media String URL or File object
@@ -993,16 +1114,24 @@ export class ProcedureService extends BaseService {
       where('isActive', '==', true),
     );
     const snapshot = await getDocs(q);
-    return snapshot.docs.map(doc => doc.data() as Procedure);
+    const procedures = snapshot.docs.map(doc => doc.data() as Procedure);
+    
+    // Filter out procedures from draft practitioners
+    return await this.filterDraftPractitionerProcedures(procedures);
   }
 
   /**
    * Gets all procedures for a practitioner
    * @param practitionerId - The ID of the practitioner
    * @param clinicBranchId - Optional clinic branch ID to filter by
+   * @param excludeDraftPractitioners - Whether to exclude procedures if the practitioner is in DRAFT status
    * @returns List of procedures
    */
-  async getProceduresByPractitioner(practitionerId: string, clinicBranchId?: string): Promise<Procedure[]> {
+  async getProceduresByPractitioner(
+    practitionerId: string, 
+    clinicBranchId?: string,
+    excludeDraftPractitioners: boolean = true
+  ): Promise<Procedure[]> {
     const constraints: QueryConstraint[] = [
       where('practitionerId', '==', practitionerId),
       where('isActive', '==', true),
@@ -1017,7 +1146,23 @@ export class ProcedureService extends BaseService {
       ...constraints
     );
     const snapshot = await getDocs(q);
-    return snapshot.docs.map(doc => doc.data() as Procedure);
+    const procedures = snapshot.docs.map(doc => doc.data() as Procedure);
+
+    // If we need to exclude draft practitioners and have the service available
+    if (excludeDraftPractitioners && this.practitionerService) {
+      try {
+        const practitioner = await this.practitionerService.getPractitioner(practitionerId);
+        if (practitioner && practitioner.status === PractitionerStatus.DRAFT) {
+          console.log(`[ProcedureService] Excluding procedures for draft practitioner ${practitionerId}`);
+          return [];
+        }
+      } catch (error) {
+        console.error(`[ProcedureService] Error checking practitioner status for ${practitionerId}:`, error);
+        // On error, default to returning procedures to avoid breaking UI
+      }
+    }
+
+    return procedures;
   }
 
   /**
@@ -1285,11 +1430,13 @@ export class ProcedureService extends BaseService {
    *
    * @param pagination - Optional number of procedures per page (0 or undefined returns all)
    * @param lastDoc - Optional last document for pagination (if continuing from a previous page)
+   * @param excludeDraftPractitioners - Whether to exclude procedures from draft practitioners (default: true)
    * @returns Object containing procedures array and the last document for pagination
    */
   async getAllProcedures(
     pagination?: number,
     lastDoc?: any,
+    excludeDraftPractitioners: boolean = true,
   ): Promise<{ procedures: Procedure[]; lastDoc: any }> {
     try {
       const proceduresCollection = collection(this.db, PROCEDURES_COLLECTION);
@@ -1316,7 +1463,7 @@ export class ProcedureService extends BaseService {
       const proceduresSnapshot = await getDocs(proceduresQuery);
       const lastVisible = proceduresSnapshot.docs[proceduresSnapshot.docs.length - 1];
 
-      const procedures = proceduresSnapshot.docs.map(doc => {
+      let procedures = proceduresSnapshot.docs.map(doc => {
         const data = doc.data() as Procedure;
         return {
           ...data,
@@ -1324,6 +1471,11 @@ export class ProcedureService extends BaseService {
         };
       });
 
+      // Filter out procedures from draft practitioners if requested
+      if (excludeDraftPractitioners) {
+        procedures = await this.filterDraftPractitionerProcedures(procedures);
+      }
+
       return {
         procedures,
         lastDoc: lastVisible,
@@ -1494,6 +1646,9 @@ export class ProcedureService extends BaseService {
             procedures = this.applyInMemoryFilters(procedures, filters);
           }
           
+          // Filter out procedures from draft practitioners
+          procedures = await this.filterDraftPractitionerProcedures(procedures);
+          
           const lastDoc =
             querySnapshot.docs.length > 0
               ? querySnapshot.docs[querySnapshot.docs.length - 1]
@@ -1551,6 +1706,9 @@ export class ProcedureService extends BaseService {
             procedures = this.applyInMemoryFilters(procedures, filters);
           }
           
+          // Filter out procedures from draft practitioners
+          procedures = await this.filterDraftPractitionerProcedures(procedures);
+          
           const lastDoc =
             querySnapshot.docs.length > 0
               ? querySnapshot.docs[querySnapshot.docs.length - 1]
@@ -1660,6 +1818,10 @@ export class ProcedureService extends BaseService {
           },
         });
         procedures = this.applyInMemoryFilters(procedures, filters);
+        
+        // Filter out procedures from draft practitioners
+        procedures = await this.filterDraftPractitionerProcedures(procedures);
+        
         console.log('[PROCEDURE_SERVICE] After applyInMemoryFilters (Strategy 3):', {
           procedureCount: procedures.length,
         });
@@ -1700,6 +1862,9 @@ export class ProcedureService extends BaseService {
 
         // Apply all client-side filters using centralized function
         procedures = this.applyInMemoryFilters(procedures, filters);
+        
+        // Filter out procedures from draft practitioners
+        procedures = await this.filterDraftPractitionerProcedures(procedures);
 
         const lastDoc =
           querySnapshot.docs.length > 0 ? querySnapshot.docs[querySnapshot.docs.length - 1] : null;