@blackcode_sa/metaestetics-api 1.8.15 → 1.8.17

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

@@ -1116,8 +1116,9 @@ export class PractitionerService extends BaseService {
 
         // Add other filters that work well with Firestore
         if (filters.certifications && filters.certifications.length > 0) {
+          const certificationsToMatch = filters.certifications as CertificationSpecialty[];
           constraints.push(
-            where("certification.specialties", "array-contains-any", filters.certifications)
+            where("certification.specialties", "array-contains-any", certificationsToMatch)
           );
         }
 
@@ -1171,22 +1172,8 @@ export class PractitionerService extends BaseService {
           practitioners = practitioners.slice(0, filters.pagination || 10);
         }
 
-        // Apply client-side name filtering if needed
-        if (filters.nameSearch && filters.nameSearch.trim()) {
-          const searchTerm = filters.nameSearch.trim().toLowerCase();
-          practitioners = practitioners.filter(practitioner => {
-            const firstName = (practitioner.basicInfo?.firstName || '').toLowerCase();
-            const lastName = (practitioner.basicInfo?.lastName || '').toLowerCase();
-            const fullName = `${firstName} ${lastName}`.trim();
-            const fullNameLower = practitioner.fullNameLower || '';
-            
-            return firstName.includes(searchTerm) || 
-                   lastName.includes(searchTerm) || 
-                   fullName.includes(searchTerm) ||
-                   fullNameLower.includes(searchTerm);
-          });
-          console.log(`[PRACTITIONER_SERVICE] Applied name filter, results: ${practitioners.length}`);
-        }
+        // Apply all remaining client-side filters using centralized function
+        practitioners = this.applyInMemoryFilters(practitioners, filters);
 
         const lastDoc = querySnapshot.docs.length > 0 ? querySnapshot.docs[querySnapshot.docs.length - 1] : null;
         console.log(`[PRACTITIONER_SERVICE] Strategy 2 success: ${practitioners.length} practitioners`);
@@ -1213,22 +1200,8 @@ export class PractitionerService extends BaseService {
         const querySnapshot = await getDocs(q);
         let practitioners = querySnapshot.docs.map(doc => ({ ...doc.data(), id: doc.id } as Practitioner));
 
-        // Apply client-side name filtering if needed
-        if (filters.nameSearch && filters.nameSearch.trim()) {
-          const searchTerm = filters.nameSearch.trim().toLowerCase();
-          practitioners = practitioners.filter(practitioner => {
-            const firstName = (practitioner.basicInfo?.firstName || '').toLowerCase();
-            const lastName = (practitioner.basicInfo?.lastName || '').toLowerCase();
-            const fullName = `${firstName} ${lastName}`.trim();
-            const fullNameLower = practitioner.fullNameLower || '';
-            
-            return firstName.includes(searchTerm) || 
-                   lastName.includes(searchTerm) || 
-                   fullName.includes(searchTerm) ||
-                   fullNameLower.includes(searchTerm);
-          });
-          console.log(`[PRACTITIONER_SERVICE] Applied name filter, results: ${practitioners.length}`);
-        }
+        // Apply all client-side filters using centralized function
+        practitioners = this.applyInMemoryFilters(practitioners, filters);
 
         const lastDoc = querySnapshot.docs.length > 0 ? querySnapshot.docs[querySnapshot.docs.length - 1] : null;
         console.log(`[PRACTITIONER_SERVICE] Strategy 3 success: ${practitioners.length} practitioners`);
@@ -1252,6 +1225,118 @@ export class PractitionerService extends BaseService {
     }
   }
 
+  /**
+   * Applies in-memory filters to practitioners array
+   * Used when Firestore queries fail or for complex filtering
+   */
+  private applyInMemoryFilters(practitioners: Practitioner[], filters: any): Practitioner[] {
+    let filteredPractitioners = [...practitioners]; // Create copy to avoid mutating original
+
+    // Name search filter
+    if (filters.nameSearch && filters.nameSearch.trim()) {
+      const searchTerm = filters.nameSearch.trim().toLowerCase();
+      filteredPractitioners = filteredPractitioners.filter(practitioner => {
+        const firstName = (practitioner.basicInfo?.firstName || '').toLowerCase();
+        const lastName = (practitioner.basicInfo?.lastName || '').toLowerCase();
+        const fullName = `${firstName} ${lastName}`.trim();
+        const fullNameLower = practitioner.fullNameLower || '';
+        
+        return firstName.includes(searchTerm) || 
+               lastName.includes(searchTerm) || 
+               fullName.includes(searchTerm) ||
+               fullNameLower.includes(searchTerm);
+      });
+      console.log(`[PRACTITIONER_SERVICE] Applied name filter, results: ${filteredPractitioners.length}`);
+    }
+
+    // Certifications filtering
+    if (filters.certifications && filters.certifications.length > 0) {
+      const certificationsToMatch = filters.certifications;
+      filteredPractitioners = filteredPractitioners.filter(practitioner => {
+        const practitionerCerts = practitioner.certification?.specialties || [];
+        return certificationsToMatch.some((cert: any) => practitionerCerts.includes(cert as CertificationSpecialty));
+      });
+      console.log(`[PRACTITIONER_SERVICE] Applied certifications filter, results: ${filteredPractitioners.length}`);
+    }
+
+    // Specialties filtering  
+    if (filters.specialties && filters.specialties.length > 0) {
+      const specialtiesToMatch = filters.specialties;
+      filteredPractitioners = filteredPractitioners.filter(practitioner => {
+        const practitionerSpecs = practitioner.certification?.specialties || [];
+        return specialtiesToMatch.some((spec: any) => practitionerSpecs.includes(spec));
+      });
+      console.log(`[PRACTITIONER_SERVICE] Applied specialties filter, results: ${filteredPractitioners.length}`);
+    }
+
+    // Rating filtering
+    if (filters.minRating !== undefined || filters.maxRating !== undefined) {
+      filteredPractitioners = filteredPractitioners.filter(practitioner => {
+        const rating = practitioner.reviewInfo?.averageRating || 0;
+        if (filters.minRating !== undefined && rating < filters.minRating) return false;
+        if (filters.maxRating !== undefined && rating > filters.maxRating) return false;
+        return true;
+      });
+      console.log(`[PRACTITIONER_SERVICE] Applied rating filter, results: ${filteredPractitioners.length}`);
+    }
+
+    // Procedure family filtering
+    if (filters.procedureFamily) {
+      filteredPractitioners = filteredPractitioners.filter(practitioner => {
+        const proceduresInfo = practitioner.proceduresInfo || [];
+        return proceduresInfo.some(proc => proc.family === filters.procedureFamily);
+      });
+      console.log(`[PRACTITIONER_SERVICE] Applied procedure family filter, results: ${filteredPractitioners.length}`);
+    }
+
+    // Procedure category filtering
+    if (filters.procedureCategory) {
+      filteredPractitioners = filteredPractitioners.filter(practitioner => {
+        const proceduresInfo = practitioner.proceduresInfo || [];
+        return proceduresInfo.some(proc => proc.categoryName === filters.procedureCategory);
+      });
+      console.log(`[PRACTITIONER_SERVICE] Applied procedure category filter, results: ${filteredPractitioners.length}`);
+    }
+
+    // Procedure subcategory filtering
+    if (filters.procedureSubcategory) {
+      filteredPractitioners = filteredPractitioners.filter(practitioner => {
+        const proceduresInfo = practitioner.proceduresInfo || [];
+        return proceduresInfo.some(proc => proc.subcategoryName === filters.procedureSubcategory);
+      });
+      console.log(`[PRACTITIONER_SERVICE] Applied procedure subcategory filter, results: ${filteredPractitioners.length}`);
+    }
+
+    // Procedure technology filtering
+    if (filters.procedureTechnology) {
+      filteredPractitioners = filteredPractitioners.filter(practitioner => {
+        const proceduresInfo = practitioner.proceduresInfo || [];
+        return proceduresInfo.some(proc => proc.technologyName === filters.procedureTechnology);
+      });
+      console.log(`[PRACTITIONER_SERVICE] Applied procedure technology filter, results: ${filteredPractitioners.length}`);
+    }
+
+    // Geo-radius filter
+    if (filters.location && filters.radiusInKm && filters.radiusInKm > 0) {
+      const location = filters.location;
+      const radiusInKm = filters.radiusInKm;
+      filteredPractitioners = filteredPractitioners.filter((practitioner) => {
+        const clinics = practitioner.clinicsInfo || [];
+        return clinics.some((clinic) => {
+          const distance = distanceBetween(
+            [location.latitude, location.longitude],
+            [clinic.location.latitude, clinic.location.longitude]
+          );
+          const distanceInKm = distance / 1000;
+          return distanceInKm <= radiusInKm;
+        });
+      });
+      console.log(`[PRACTITIONER_SERVICE] Applied geo filter, results: ${filteredPractitioners.length}`);
+    }
+
+    return filteredPractitioners;
+  }
+
   /**
    * Enables free consultation for a practitioner in a specific clinic
    * Creates a free consultation procedure with hardcoded parameters

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

@@ -960,7 +960,8 @@ export class ProcedureService extends BaseService {
           constraints.push(where("reviewInfo.averageRating", "<=", filters.maxRating));
         }
         if (filters.treatmentBenefits && filters.treatmentBenefits.length > 0) {
-          constraints.push(where("treatmentBenefits", "array-contains-any", filters.treatmentBenefits));
+          const benefitsToMatch = filters.treatmentBenefits;
+          constraints.push(where("treatmentBenefits", "array-contains-any", benefitsToMatch));
         }
 
         return constraints;
@@ -1063,16 +1064,8 @@ export class ProcedureService extends BaseService {
         const querySnapshot = await getDocs(q);
         let procedures = querySnapshot.docs.map(doc => ({ ...doc.data(), id: doc.id } as Procedure));
 
-        // Poboljšan client-side name filtering
-        if (filters.nameSearch && filters.nameSearch.trim()) {
-          const searchTerm = filters.nameSearch.trim().toLowerCase();
-          procedures = procedures.filter(procedure => {
-            const name = (procedure.name || '').toLowerCase();
-            const nameLower = procedure.nameLower || '';
-            return name.includes(searchTerm) || nameLower.includes(searchTerm);
-          });
-          console.log(`[PROCEDURE_SERVICE] Applied name filter, results: ${procedures.length}`);
-        }
+        // Apply all client-side filters using centralized function
+        procedures = this.applyInMemoryFilters(procedures, filters);
 
         const lastDoc = querySnapshot.docs.length > 0 ? querySnapshot.docs[querySnapshot.docs.length - 1] : null;
         console.log(`[PROCEDURE_SERVICE] Strategy 3 success: ${procedures.length} procedures`);
@@ -1099,16 +1092,8 @@ export class ProcedureService extends BaseService {
         const querySnapshot = await getDocs(q);
         let procedures = querySnapshot.docs.map(doc => ({ ...doc.data(), id: doc.id } as Procedure));
 
-        // Poboljšan client-side name filtering
-        if (filters.nameSearch && filters.nameSearch.trim()) {
-          const searchTerm = filters.nameSearch.trim().toLowerCase();
-          procedures = procedures.filter(procedure => {
-            const name = (procedure.name || '').toLowerCase();
-            const nameLower = procedure.nameLower || '';
-            return name.includes(searchTerm) || nameLower.includes(searchTerm);
-          });
-          console.log(`[PROCEDURE_SERVICE] Applied name filter, results: ${procedures.length}`);
-        }
+        // Apply all client-side filters using centralized function
+        procedures = this.applyInMemoryFilters(procedures, filters);
 
         const lastDoc = querySnapshot.docs.length > 0 ? querySnapshot.docs[querySnapshot.docs.length - 1] : null;
         console.log(`[PROCEDURE_SERVICE] Strategy 4 success: ${procedures.length} procedures`);
@@ -1132,6 +1117,109 @@ export class ProcedureService extends BaseService {
     }
   }
 
+  /**
+   * Applies in-memory filters to procedures array
+   * Used when Firestore queries fail or for complex filtering
+   */
+  private applyInMemoryFilters(procedures: Procedure[], filters: any): (Procedure & { distance?: number })[] {
+    let filteredProcedures = [...procedures]; // Create copy to avoid mutating original
+
+    // Name search filter
+    if (filters.nameSearch && filters.nameSearch.trim()) {
+      const searchTerm = filters.nameSearch.trim().toLowerCase();
+      filteredProcedures = filteredProcedures.filter(procedure => {
+        const name = (procedure.name || '').toLowerCase();
+        const nameLower = procedure.nameLower || '';
+        return name.includes(searchTerm) || nameLower.includes(searchTerm);
+      });
+      console.log(`[PROCEDURE_SERVICE] Applied name filter, results: ${filteredProcedures.length}`);
+    }
+
+    // Price filtering
+    if (filters.minPrice !== undefined || filters.maxPrice !== undefined) {
+      filteredProcedures = filteredProcedures.filter(procedure => {
+        const price = procedure.price || 0;
+        if (filters.minPrice !== undefined && price < filters.minPrice) return false;
+        if (filters.maxPrice !== undefined && price > filters.maxPrice) return false;
+        return true;
+      });
+      console.log(`[PROCEDURE_SERVICE] Applied price filter (${filters.minPrice}-${filters.maxPrice}), results: ${filteredProcedures.length}`);
+    }
+
+    // Rating filtering
+    if (filters.minRating !== undefined || filters.maxRating !== undefined) {
+      filteredProcedures = filteredProcedures.filter(procedure => {
+        const rating = procedure.reviewInfo?.averageRating || 0;
+        if (filters.minRating !== undefined && rating < filters.minRating) return false;
+        if (filters.maxRating !== undefined && rating > filters.maxRating) return false;
+        return true;
+      });
+      console.log(`[PROCEDURE_SERVICE] Applied rating filter, results: ${filteredProcedures.length}`);
+    }
+
+    // Treatment benefits filtering
+    if (filters.treatmentBenefits && filters.treatmentBenefits.length > 0) {
+      const benefitsToMatch = filters.treatmentBenefits;
+      filteredProcedures = filteredProcedures.filter(procedure => {
+        const procedureBenefits = procedure.treatmentBenefits || [];
+        return benefitsToMatch.some((benefit: any) => procedureBenefits.includes(benefit));
+      });
+      console.log(`[PROCEDURE_SERVICE] Applied benefits filter, results: ${filteredProcedures.length}`);
+    }
+
+    // Procedure family filtering
+    if (filters.procedureFamily) {
+      filteredProcedures = filteredProcedures.filter(procedure => procedure.family === filters.procedureFamily);
+      console.log(`[PROCEDURE_SERVICE] Applied family filter, results: ${filteredProcedures.length}`);
+    }
+
+    // Category filtering
+    if (filters.procedureCategory) {
+      filteredProcedures = filteredProcedures.filter(procedure => procedure.category?.id === filters.procedureCategory);
+      console.log(`[PROCEDURE_SERVICE] Applied category filter, results: ${filteredProcedures.length}`);
+    }
+
+    // Subcategory filtering
+    if (filters.procedureSubcategory) {
+      filteredProcedures = filteredProcedures.filter(procedure => procedure.subcategory?.id === filters.procedureSubcategory);
+      console.log(`[PROCEDURE_SERVICE] Applied subcategory filter, results: ${filteredProcedures.length}`);
+    }
+
+    // Technology filtering
+    if (filters.procedureTechnology) {
+      filteredProcedures = filteredProcedures.filter(procedure => procedure.technology?.id === filters.procedureTechnology);
+      console.log(`[PROCEDURE_SERVICE] Applied technology filter, results: ${filteredProcedures.length}`);
+    }
+
+    // Geo-radius filter
+    if (filters.location && filters.radiusInKm && filters.radiusInKm > 0) {
+      const location = filters.location;
+      const radiusInKm = filters.radiusInKm;
+      filteredProcedures = filteredProcedures.filter(procedure => {
+        const clinicLocation = procedure.clinicInfo?.location;
+        if (!clinicLocation?.latitude || !clinicLocation?.longitude) {
+          return false;
+        }
+        
+        const distance = distanceBetween(
+          [location.latitude, location.longitude],
+          [clinicLocation.latitude, clinicLocation.longitude]
+        ) / 1000; // Convert to km
+        
+        // Attach distance for frontend sorting/display
+        (procedure as any).distance = distance;
+        
+        return distance <= radiusInKm;
+      });
+      console.log(`[PROCEDURE_SERVICE] Applied geo filter, results: ${filteredProcedures.length}`);
+      
+      // Sort by distance when geo filtering is applied
+      filteredProcedures.sort((a, b) => ((a as any).distance || 0) - ((b as any).distance || 0));
+    }
+
+    return filteredProcedures as (Procedure & { distance?: number })[];
+  }
+
   private handleGeoQuery(filters: any): Promise<{ procedures: (Procedure & { distance?: number })[]; lastDoc: any }> {
     console.log('[PROCEDURE_SERVICE] Executing geo query with enhanced debugging');
     
@@ -1160,29 +1248,8 @@ export class ProcedureService extends BaseService {
       return getDocs(q).then(querySnapshot => {
         let procedures = querySnapshot.docs.map(doc => ({ ...doc.data(), id: doc.id } as Procedure));
         
-        // Apply geo filtering
-        procedures = procedures.filter(procedure => {
-          const clinicLocation = procedure.clinicInfo?.location;
-          if (!clinicLocation?.latitude || !clinicLocation?.longitude) {
-            return false;
-          }
-          
-          const distance = distanceBetween(
-            [location.latitude, location.longitude],
-            [clinicLocation.latitude, clinicLocation.longitude]
-          ) / 1000; // Convert to km
-          
-          // Add distance to procedure object
-          (procedure as any).distance = distance;
-          
-          return distance <= radiusInKm;
-        });
-
-        // Sort by distance
-        procedures.sort((a, b) => ((a as any).distance || 0) - ((b as any).distance || 0));
-        
-        // Limit to pagination size
-        procedures = procedures.slice(0, filters.pagination || 10);
+        // Apply all filters using centralized function (includes geo filtering)
+        procedures = this.applyInMemoryFilters(procedures, filters);
         
         console.log(`[PROCEDURE_SERVICE] Geo query success: ${procedures.length} procedures within ${radiusInKm}km`);