@blackcode_sa/metaestetics-api 1.5.29 → 1.5.31

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

@@ -16,6 +16,10 @@ import {
   arrayRemove,
   FieldValue,
   orderBy,
+  limit,
+  startAfter,
+  QueryConstraint,
+  documentId,
 } from "firebase/firestore";
 import { BaseService } from "../base.service";
 import {
@@ -64,6 +68,8 @@ import {
 } from "../../backoffice/types";
 import { Clinic, CLINICS_COLLECTION } from "../../types/clinic";
 import { ProcedureReviewInfo } from "../../types/reviews";
+import { distanceBetween, geohashQueryBounds } from "geofire-common";
+import { TreatmentBenefit } from "../../backoffice/types/static/treatment-benefit.types";
 
 export class ProcedureService extends BaseService {
   private categoryService: CategoryService;
@@ -87,143 +93,8 @@ export class ProcedureService extends BaseService {
     this.productService = productService;
   }
 
-  // Helper function to create ProcedureSummaryInfo
-  private _createProcedureSummaryInfo(
-    procedure: Procedure
-  ): ProcedureSummaryInfo {
-    // Ensure nested objects and names exist before accessing them
-    const categoryName = procedure.category?.name || "N/A";
-    const subcategoryName = procedure.subcategory?.name || "N/A";
-    const technologyName = procedure.technology?.name || "N/A";
-    const clinicName = procedure.clinicInfo?.name || "N/A";
-    const practitionerName = procedure.doctorInfo?.name || "N/A";
-
-    return {
-      id: procedure.id,
-      name: procedure.name,
-      description: procedure.description || "",
-      photo: "", // No photo source identified yet
-      family: procedure.family,
-      categoryName: categoryName,
-      subcategoryName: subcategoryName,
-      technologyName: technologyName,
-      price: procedure.price,
-      pricingMeasure: procedure.pricingMeasure,
-      currency: procedure.currency,
-      duration: procedure.duration,
-      clinicId: procedure.clinicBranchId,
-      clinicName: clinicName,
-      practitionerId: procedure.practitionerId,
-      practitionerName: practitionerName,
-    };
-  }
-
-  // Helper to update practitioner's procedures
-  private async _updatePractitionerProcedures(
-    practitionerId: string,
-    procedureSummary: ProcedureSummaryInfo | null, // Null means remove
-    procedureIdToRemove?: string
-  ) {
-    const practitionerRef = doc(
-      this.db,
-      PRACTITIONERS_COLLECTION,
-      practitionerId
-    );
-    const updateData: { [key: string]: FieldValue } = {};
-
-    if (procedureSummary) {
-      // Add/Update
-      updateData["procedures"] = arrayUnion(procedureSummary.id);
-      // Remove old summary first (by ID) then add new one to ensure update
-      updateData["proceduresInfo"] = arrayRemove(
-        ...[
-          // Need to spread the arrayRemove arguments
-          // Create a 'matcher' object with only the ID for removal
-          { id: procedureSummary.id },
-        ]
-      );
-      // We'll add the new summary in a separate update to avoid conflicts if needed, or rely on a subsequent transaction/batch commit
-    } else if (procedureIdToRemove) {
-      // Remove
-      updateData["procedures"] = arrayRemove(procedureIdToRemove);
-      updateData["proceduresInfo"] = arrayRemove(
-        ...[{ id: procedureIdToRemove }] // Use matcher for removal
-      );
-    } else {
-      return; // No operation needed
-    }
-
-    updateData["updatedAt"] = serverTimestamp();
-
-    // Perform the update
-    const batch = writeBatch(this.db);
-    batch.update(practitionerRef, updateData);
-
-    // If adding/updating, add the new summary info after removing the old one
-    if (procedureSummary) {
-      batch.update(practitionerRef, {
-        proceduresInfo: arrayUnion(procedureSummary),
-      });
-    }
-
-    await batch.commit();
-  }
-
-  // Helper to update clinic's procedures
-  private async _updateClinicProcedures(
-    clinicId: string,
-    procedureSummary: ProcedureSummaryInfo | null, // Null means remove
-    procedureIdToRemove?: string
-  ) {
-    const clinicRef = doc(this.db, CLINICS_COLLECTION, clinicId);
-
-    // Check if clinic exists before attempting update
-    const clinicSnap = await getDoc(clinicRef);
-    if (!clinicSnap.exists()) {
-      console.warn(
-        `Clinic ${clinicId} not found, skipping procedure aggregation update.`
-      );
-      return;
-    }
-
-    const updateData: { [key: string]: FieldValue } = {};
-
-    if (procedureSummary) {
-      // Add/Update - Using arrayUnion for simplicity, assuming procedure IDs are unique in services array too
-      // Note: 'services' array might be deprecated or used differently now
-      updateData["services"] = arrayUnion(procedureSummary.id);
-      // Remove old summary first (by ID) then add new one to ensure update
-      updateData["proceduresInfo"] = arrayRemove(
-        ...[{ id: procedureSummary.id }] // Use matcher for removal
-      );
-    } else if (procedureIdToRemove) {
-      // Remove
-      updateData["services"] = arrayRemove(procedureIdToRemove);
-      updateData["proceduresInfo"] = arrayRemove(
-        ...[{ id: procedureIdToRemove }] // Use matcher for removal
-      );
-    } else {
-      return; // No operation needed
-    }
-
-    updateData["updatedAt"] = serverTimestamp();
-
-    // Perform the update
-    const batch = writeBatch(this.db);
-    batch.update(clinicRef, updateData);
-
-    // If adding/updating, add the new summary info after removing the old one
-    if (procedureSummary) {
-      batch.update(clinicRef, {
-        proceduresInfo: arrayUnion(procedureSummary),
-      });
-    }
-
-    await batch.commit();
-  }
-
   /**
-   * Creates a new procedure and updates related practitioner/clinic aggregates
+   * Creates a new procedure
    * @param data - The data for creating a new procedure
    * @returns The created procedure
    */
@@ -289,14 +160,13 @@ export class ProcedureService extends BaseService {
     };
 
     // Create aggregated doctor info for the procedure document
-    // Re-use logic from previous implementation or simplify
     const doctorInfo = {
       id: practitionerSnapshot.id,
       name: `${practitioner.basicInfo.firstName} ${practitioner.basicInfo.lastName}`,
       description: practitioner.basicInfo.bio || "",
       photo: practitioner.basicInfo.profileImageUrl || "",
-      rating: practitioner.reviewInfo?.averageRating || 0, // Example rating source
-      services: practitioner.procedures || [], // Link services to practitioner's procedures
+      rating: practitioner.reviewInfo?.averageRating || 0,
+      services: practitioner.procedures || [],
     };
 
     // Create the procedure object
@@ -330,48 +200,14 @@ export class ProcedureService extends BaseService {
       isActive: true, // Default to active
     };
 
-    // --- Transaction/Batch Start ---
-    const batch = writeBatch(this.db);
-
-    // 1. Create the procedure document
+    // Create the procedure document
     const procedureRef = doc(this.db, PROCEDURES_COLLECTION, procedureId);
-    batch.set(procedureRef, {
+    await setDoc(procedureRef, {
       ...newProcedure,
       createdAt: serverTimestamp(),
       updatedAt: serverTimestamp(),
     });
 
-    // 2. Create the summary object AFTER the main object is defined
-    const procedureSummary = this._createProcedureSummaryInfo({
-      ...newProcedure,
-      createdAt: new Date(), // Use placeholder date for summary creation
-      updatedAt: new Date(),
-    });
-
-    // 3. Update Practitioner
-    const practitionerUpdateData: { [key: string]: FieldValue } = {
-      procedures: arrayUnion(procedureId),
-      proceduresInfo: arrayUnion(procedureSummary),
-      updatedAt: serverTimestamp(),
-    };
-    batch.update(practitionerRef, practitionerUpdateData);
-
-    // 4. Update Clinic
-    const clinicUpdateData: { [key: string]: FieldValue } = {
-      // services: arrayUnion(procedureId), // Decide if 'services' array is still needed
-      proceduresInfo: arrayUnion(procedureSummary),
-      // Potentially update clinic.doctors array if not already present
-      doctors: arrayUnion(validatedData.practitionerId),
-      // Potentially update clinic.doctorsInfo array
-      // This requires fetching existing doctorsInfo and adding/updating
-      // For simplicity now, we'll just add the procedure summary
-      updatedAt: serverTimestamp(),
-    };
-    batch.update(clinicRef, clinicUpdateData);
-
-    // --- Transaction/Batch Commit ---
-    await batch.commit();
-
     // Return the created procedure (fetch again to get server timestamps)
     const savedDoc = await getDoc(procedureRef);
     return savedDoc.data() as Procedure;
@@ -428,7 +264,7 @@ export class ProcedureService extends BaseService {
   }
 
   /**
-   * Updates a procedure and its related aggregates in Practitioner and Clinic docs
+   * Updates a procedure
    * @param id - The ID of the procedure to update
    * @param data - The data to update the procedure with
    * @returns The updated procedure
@@ -578,131 +414,19 @@ export class ProcedureService extends BaseService {
       console.warn("Attempted to update product without a valid technologyId");
     }
 
-    // --- Perform updates using a batch ---
-    const batch = writeBatch(this.db);
-
-    // 1. Update the main procedure document
-    batch.update(procedureRef, {
+    // Update the procedure document
+    await updateDoc(procedureRef, {
       ...updatedProcedureData,
       updatedAt: serverTimestamp(),
     });
 
-    // 2. Create the updated summary info object
-    // We need the final state of the procedure for the summary
-    const finalProcedureStateForSummary = {
-      ...existingProcedure,
-      ...updatedProcedureData, // Apply updates
-      // Ensure nested objects needed for summary are present
-      category: updatedProcedureData.category || existingProcedure.category,
-      subcategory:
-        updatedProcedureData.subcategory || existingProcedure.subcategory,
-      technology:
-        updatedProcedureData.technology || existingProcedure.technology,
-      product: updatedProcedureData.product || existingProcedure.product,
-      clinicInfo:
-        updatedProcedureData.clinicInfo || existingProcedure.clinicInfo,
-      doctorInfo:
-        updatedProcedureData.doctorInfo || existingProcedure.doctorInfo,
-      practitionerId:
-        validatedData.practitionerId || existingProcedure.practitionerId, // Use potentially updated IDs
-      clinicBranchId:
-        validatedData.clinicBranchId || existingProcedure.clinicBranchId,
-    } as Procedure; // Cast because we're merging potentially partial data
-
-    const updatedProcedureSummary = this._createProcedureSummaryInfo(
-      finalProcedureStateForSummary
-    );
-
-    // 3. Update Practitioner(s)
-    if (practitionerChanged) {
-      // Remove from old practitioner
-      const oldPractitionerRef = doc(
-        this.db,
-        PRACTITIONERS_COLLECTION,
-        oldPractitionerId
-      );
-      batch.update(oldPractitionerRef, {
-        procedures: arrayRemove(id),
-        proceduresInfo: arrayRemove(...[{ id: id }]), // Matcher for removal
-        updatedAt: serverTimestamp(),
-      });
-      // Add to new practitioner
-      const newPractitionerRef = doc(
-        this.db,
-        PRACTITIONERS_COLLECTION,
-        updatedProcedureSummary.practitionerId
-      );
-      batch.update(newPractitionerRef, {
-        procedures: arrayUnion(id),
-        proceduresInfo: arrayUnion(updatedProcedureSummary),
-        updatedAt: serverTimestamp(),
-      });
-    } else {
-      // Update in place for the current practitioner
-      const currentPractitionerRef = doc(
-        this.db,
-        PRACTITIONERS_COLLECTION,
-        oldPractitionerId
-      );
-      // Remove old first
-      batch.update(currentPractitionerRef, {
-        proceduresInfo: arrayRemove(...[{ id: id }]),
-        updatedAt: serverTimestamp(),
-      });
-      // Add updated
-      batch.update(currentPractitionerRef, {
-        proceduresInfo: arrayUnion(updatedProcedureSummary),
-        updatedAt: serverTimestamp(),
-      });
-    }
-
-    // 4. Update Clinic(s)
-    if (clinicChanged) {
-      // Remove from old clinic
-      const oldClinicRef = doc(this.db, CLINICS_COLLECTION, oldClinicId);
-      batch.update(oldClinicRef, {
-        // services: arrayRemove(id),
-        proceduresInfo: arrayRemove(...[{ id: id }]), // Matcher for removal
-        updatedAt: serverTimestamp(),
-        // Potentially remove from clinic.doctors and clinic.doctorsInfo if practitioner also changed or was last one for this clinic
-      });
-      // Add to new clinic
-      const newClinicRef = doc(
-        this.db,
-        CLINICS_COLLECTION,
-        updatedProcedureSummary.clinicId
-      );
-      batch.update(newClinicRef, {
-        // services: arrayUnion(id),
-        proceduresInfo: arrayUnion(updatedProcedureSummary),
-        doctors: arrayUnion(updatedProcedureSummary.practitionerId), // Ensure practitioner is listed
-        updatedAt: serverTimestamp(),
-      });
-    } else {
-      // Update in place for the current clinic
-      const currentClinicRef = doc(this.db, CLINICS_COLLECTION, oldClinicId);
-      // Remove old first
-      batch.update(currentClinicRef, {
-        proceduresInfo: arrayRemove(...[{ id: id }]),
-        updatedAt: serverTimestamp(),
-      });
-      // Add updated
-      batch.update(currentClinicRef, {
-        proceduresInfo: arrayUnion(updatedProcedureSummary),
-        updatedAt: serverTimestamp(),
-      });
-    }
-
-    // --- Commit Batch ---
-    await batch.commit();
-
     // Return the updated procedure
     const updatedSnapshot = await getDoc(procedureRef);
     return updatedSnapshot.data() as Procedure;
   }
 
   /**
-   * Deactivates a procedure (soft delete) and updates aggregates
+   * Deactivates a procedure (soft delete)
    * @param id - The ID of the procedure to deactivate
    */
   async deactivateProcedure(id: string): Promise<void> {
@@ -712,51 +436,16 @@ export class ProcedureService extends BaseService {
       console.warn(`Procedure ${id} not found for deactivation.`);
       return;
     }
-    const procedure = procedureSnap.data() as Procedure;
-
-    // We treat deactivation like a deletion for the aggregated lists
-    // Alternatively, keep inactive procedures but filter them client-side
-
-    // --- Perform updates using a batch ---
-    const batch = writeBatch(this.db);
 
-    // 1. Mark procedure as inactive
-    batch.update(procedureRef, {
+    // Mark procedure as inactive
+    await updateDoc(procedureRef, {
       isActive: false,
       updatedAt: serverTimestamp(),
     });
-
-    // 2. Remove from Practitioner aggregates
-    const practitionerRef = doc(
-      this.db,
-      PRACTITIONERS_COLLECTION,
-      procedure.practitionerId
-    );
-    batch.update(practitionerRef, {
-      procedures: arrayRemove(id),
-      proceduresInfo: arrayRemove(...[{ id: id }]), // Matcher for removal
-      updatedAt: serverTimestamp(),
-    });
-
-    // 3. Remove from Clinic aggregates
-    const clinicRef = doc(
-      this.db,
-      CLINICS_COLLECTION,
-      procedure.clinicBranchId
-    );
-    batch.update(clinicRef, {
-      // services: arrayRemove(id),
-      proceduresInfo: arrayRemove(...[{ id: id }]), // Matcher for removal
-      updatedAt: serverTimestamp(),
-      // Potentially update clinic.doctors/doctorsInfo if this was the last active procedure for this doctor at this clinic
-    });
-
-    // --- Commit Batch ---
-    await batch.commit();
   }
 
   /**
-   * Deletes a procedure permanently and updates related aggregates
+   * Deletes a procedure permanently
    * @param id - The ID of the procedure to delete
    * @returns A boolean indicating if the deletion was successful
    */
@@ -769,46 +458,8 @@ export class ProcedureService extends BaseService {
       return false;
     }
 
-    const procedure = procedureSnapshot.data() as Procedure;
-
-    // --- Perform updates using a batch ---
-    const batch = writeBatch(this.db);
-
-    // 1. Remove from Practitioner aggregates
-    if (procedure.practitionerId) {
-      const practitionerRef = doc(
-        this.db,
-        PRACTITIONERS_COLLECTION,
-        procedure.practitionerId
-      );
-      batch.update(practitionerRef, {
-        procedures: arrayRemove(id),
-        proceduresInfo: arrayRemove(...[{ id: id }]), // Matcher for removal
-        updatedAt: serverTimestamp(),
-      });
-    }
-
-    // 2. Remove from Clinic aggregates
-    if (procedure.clinicBranchId) {
-      const clinicRef = doc(
-        this.db,
-        CLINICS_COLLECTION,
-        procedure.clinicBranchId
-      );
-      batch.update(clinicRef, {
-        // services: arrayRemove(id),
-        proceduresInfo: arrayRemove(...[{ id: id }]), // Matcher for removal
-        updatedAt: serverTimestamp(),
-        // Potentially update clinic.doctors/doctorsInfo
-      });
-    }
-
-    // 3. Delete the procedure document itself
-    batch.delete(procedureRef);
-
-    // --- Commit Batch ---
-    await batch.commit();
-
+    // Delete the procedure document
+    await deleteDoc(procedureRef);
     return true;
   }
 
@@ -893,4 +544,316 @@ export class ProcedureService extends BaseService {
       throw error;
     }
   }
+
+  /**
+   * Searches and filters procedures based on multiple criteria
+   *
+   * @param filters - Various filters to apply
+   * @param filters.nameSearch - Optional search text for procedure name
+   * @param filters.treatmentBenefits - Optional array of treatment benefits to filter by
+   * @param filters.procedureFamily - Optional procedure family to filter by
+   * @param filters.procedureCategory - Optional procedure category to filter by
+   * @param filters.procedureSubcategory - Optional procedure subcategory to filter by
+   * @param filters.procedureTechnology - Optional procedure technology to filter by
+   * @param filters.location - Optional location for distance-based search
+   * @param filters.radiusInKm - Optional radius in kilometers (required if location is provided)
+   * @param filters.minPrice - Optional minimum price
+   * @param filters.maxPrice - Optional maximum price
+   * @param filters.minRating - Optional minimum rating (0-5)
+   * @param filters.maxRating - Optional maximum rating (0-5)
+   * @param filters.pagination - Optional number of results per page
+   * @param filters.lastDoc - Optional last document for pagination
+   * @param filters.isActive - Optional filter for active procedures only
+   * @returns Filtered procedures and the last document for pagination
+   */
+  async getProceduresByFilters(filters: {
+    nameSearch?: string;
+    treatmentBenefits?: TreatmentBenefit[];
+    procedureFamily?: ProcedureFamily;
+    procedureCategory?: string;
+    procedureSubcategory?: string;
+    procedureTechnology?: string;
+    location?: { latitude: number; longitude: number };
+    radiusInKm?: number;
+    minPrice?: number;
+    maxPrice?: number;
+    minRating?: number;
+    maxRating?: number;
+    pagination?: number;
+    lastDoc?: any;
+    isActive?: boolean;
+  }): Promise<{
+    procedures: (Procedure & { distance?: number })[];
+    lastDoc: any;
+  }> {
+    try {
+      console.log(
+        "[PROCEDURE_SERVICE] Starting procedure filtering with criteria:",
+        filters
+      );
+
+      // Determine if we're doing a geo query or a regular query
+      const isGeoQuery =
+        filters.location && filters.radiusInKm && filters.radiusInKm > 0;
+
+      // Initialize base constraints
+      const constraints: QueryConstraint[] = [];
+
+      // Add active status filter (default to active if not specified)
+      if (filters.isActive !== undefined) {
+        constraints.push(where("isActive", "==", filters.isActive));
+      } else {
+        constraints.push(where("isActive", "==", true));
+      }
+
+      // Filter by procedure family if specified
+      if (filters.procedureFamily) {
+        constraints.push(where("family", "==", filters.procedureFamily));
+      }
+
+      // Add ordering to make pagination consistent
+      constraints.push(orderBy(documentId()));
+
+      // Add pagination if specified
+      if (filters.pagination && filters.pagination > 0 && filters.lastDoc) {
+        constraints.push(startAfter(filters.lastDoc));
+        constraints.push(limit(filters.pagination));
+      } else if (filters.pagination && filters.pagination > 0) {
+        constraints.push(limit(filters.pagination));
+      }
+
+      let proceduresResult: (Procedure & { distance?: number })[] = [];
+      let lastVisibleDoc = null;
+
+      // For geo queries, we need a different approach
+      if (isGeoQuery) {
+        const center = filters.location!;
+        const radiusInKm = filters.radiusInKm!;
+
+        // Get the geohash query bounds
+        const bounds = geohashQueryBounds(
+          [center.latitude, center.longitude],
+          radiusInKm * 1000 // Convert to meters
+        );
+
+        // Collect matching procedures from all bounds
+        const matchingProcedures: (Procedure & { distance: number })[] = [];
+
+        // Execute queries for each bound
+        for (const bound of bounds) {
+          // Create a geo query for this bound
+          const geoConstraints = [
+            ...constraints,
+            where("clinicInfo.location.geohash", ">=", bound[0]),
+            where("clinicInfo.location.geohash", "<=", bound[1]),
+          ];
+
+          const q = query(
+            collection(this.db, PROCEDURES_COLLECTION),
+            ...geoConstraints
+          );
+          const querySnapshot = await getDocs(q);
+
+          console.log(
+            `[PROCEDURE_SERVICE] Found ${querySnapshot.docs.length} procedures in geo bound`
+          );
+
+          // Process results and filter by actual distance
+          for (const doc of querySnapshot.docs) {
+            const procedure = { ...doc.data(), id: doc.id } as Procedure;
+
+            // Calculate actual distance
+            const distance = distanceBetween(
+              [center.latitude, center.longitude],
+              [
+                procedure.clinicInfo.location.latitude,
+                procedure.clinicInfo.location.longitude,
+              ]
+            );
+
+            // Convert to kilometers
+            const distanceInKm = distance / 1000;
+
+            // Check if within radius
+            if (distanceInKm <= radiusInKm) {
+              // Add distance to procedure object
+              matchingProcedures.push({
+                ...procedure,
+                distance: distanceInKm,
+              });
+            }
+          }
+        }
+
+        // Apply additional filters that couldn't be applied in the query
+        let filteredProcedures = matchingProcedures;
+
+        // Apply remaining filters in memory
+        filteredProcedures = this.applyInMemoryFilters(
+          filteredProcedures,
+          filters
+        );
+
+        // Sort by distance
+        filteredProcedures.sort((a, b) => a.distance - b.distance);
+
+        // Apply pagination after all filters have been applied
+        if (filters.pagination && filters.pagination > 0) {
+          // If we have a lastDoc, find its index
+          let startIndex = 0;
+          if (filters.lastDoc) {
+            const lastDocIndex = filteredProcedures.findIndex(
+              (procedure) => procedure.id === filters.lastDoc.id
+            );
+            if (lastDocIndex !== -1) {
+              startIndex = lastDocIndex + 1;
+            }
+          }
+
+          // Get paginated subset
+          const paginatedProcedures = filteredProcedures.slice(
+            startIndex,
+            startIndex + filters.pagination
+          );
+
+          // Set last document for next pagination
+          lastVisibleDoc =
+            paginatedProcedures.length > 0
+              ? paginatedProcedures[paginatedProcedures.length - 1]
+              : null;
+
+          proceduresResult = paginatedProcedures;
+        } else {
+          proceduresResult = filteredProcedures;
+        }
+      } else {
+        // For non-geo queries, execute a single query with all constraints
+        const q = query(
+          collection(this.db, PROCEDURES_COLLECTION),
+          ...constraints
+        );
+        const querySnapshot = await getDocs(q);
+
+        console.log(
+          `[PROCEDURE_SERVICE] Found ${querySnapshot.docs.length} procedures with regular query`
+        );
+
+        // Convert docs to procedures
+        const procedures = querySnapshot.docs.map((doc) => {
+          return { ...doc.data(), id: doc.id } as Procedure;
+        });
+
+        // Apply filters that couldn't be applied in the query
+        let filteredProcedures = this.applyInMemoryFilters(procedures, filters);
+
+        // Set last document for pagination
+        lastVisibleDoc =
+          querySnapshot.docs.length > 0
+            ? querySnapshot.docs[querySnapshot.docs.length - 1]
+            : null;
+
+        proceduresResult = filteredProcedures;
+      }
+
+      return {
+        procedures: proceduresResult,
+        lastDoc: lastVisibleDoc,
+      };
+    } catch (error) {
+      console.error("[PROCEDURE_SERVICE] Error filtering procedures:", error);
+      throw error;
+    }
+  }
+
+  /**
+   * Helper method to apply in-memory filters to procedures
+   * Used by getProceduresByFilters to apply filters that can't be done in Firestore queries
+   *
+   * @param procedures - The procedures to filter
+   * @param filters - The filters to apply
+   * @returns Filtered procedures
+   */
+  private applyInMemoryFilters<T extends Procedure & { distance?: number }>(
+    procedures: T[],
+    filters: {
+      nameSearch?: string;
+      treatmentBenefits?: TreatmentBenefit[];
+      procedureCategory?: string;
+      procedureSubcategory?: string;
+      procedureTechnology?: string;
+      minPrice?: number;
+      maxPrice?: number;
+      minRating?: number;
+      maxRating?: number;
+    }
+  ): T[] {
+    let filteredProcedures = procedures;
+
+    // Filter by name search if specified
+    if (filters.nameSearch && filters.nameSearch.trim() !== "") {
+      const searchTerm = filters.nameSearch.toLowerCase().trim();
+      filteredProcedures = filteredProcedures.filter((procedure) => {
+        return procedure.name.toLowerCase().includes(searchTerm);
+      });
+    }
+
+    // Filter by treatment benefits if specified
+    if (filters.treatmentBenefits && filters.treatmentBenefits.length > 0) {
+      filteredProcedures = filteredProcedures.filter((procedure) => {
+        // Check if procedure has all specified treatment benefits
+        return filters.treatmentBenefits!.every((benefit) =>
+          procedure.treatmentBenefits.includes(benefit)
+        );
+      });
+    }
+
+    // Filter by procedure category if specified
+    if (filters.procedureCategory) {
+      filteredProcedures = filteredProcedures.filter(
+        (procedure) => procedure.category.id === filters.procedureCategory
+      );
+    }
+
+    // Filter by procedure subcategory if specified
+    if (filters.procedureSubcategory) {
+      filteredProcedures = filteredProcedures.filter(
+        (procedure) => procedure.subcategory.id === filters.procedureSubcategory
+      );
+    }
+
+    // Filter by procedure technology if specified
+    if (filters.procedureTechnology) {
+      filteredProcedures = filteredProcedures.filter(
+        (procedure) => procedure.technology.id === filters.procedureTechnology
+      );
+    }
+
+    // Filter by price range if specified
+    if (filters.minPrice !== undefined) {
+      filteredProcedures = filteredProcedures.filter(
+        (procedure) => procedure.price >= filters.minPrice!
+      );
+    }
+
+    if (filters.maxPrice !== undefined) {
+      filteredProcedures = filteredProcedures.filter(
+        (procedure) => procedure.price <= filters.maxPrice!
+      );
+    }
+
+    // Filter by rating if specified
+    if (filters.minRating !== undefined) {
+      filteredProcedures = filteredProcedures.filter(
+        (procedure) => procedure.reviewInfo.averageRating >= filters.minRating!
+      );
+    }
+
+    if (filters.maxRating !== undefined) {
+      filteredProcedures = filteredProcedures.filter(
+        (procedure) => procedure.reviewInfo.averageRating <= filters.maxRating!
+      );
+    }
+
+    return filteredProcedures;
+  }
 }