@blackcode_sa/metaestetics-api 1.8.17 → 1.10.0

package/src/services/clinic/utils/filter.utils.ts

@@ -9,9 +9,9 @@ import {
   limit,
   documentId,
   orderBy,
-} from "firebase/firestore";
-import { Clinic, ClinicTag, CLINICS_COLLECTION } from "../../../types/clinic";
-import { geohashQueryBounds, distanceBetween } from "geofire-common";
+} from 'firebase/firestore';
+import { Clinic, ClinicTag, CLINICS_COLLECTION } from '../../../types/clinic';
+import { geohashQueryBounds, distanceBetween } from 'geofire-common';
 
 /**
  * Get clinics based on multiple filtering criteria with fallback strategies
@@ -36,22 +36,22 @@ export async function getClinicsByFilters(
     pagination?: number;
     lastDoc?: any;
     isActive?: boolean;
-  }
+  },
 ): Promise<{
   clinics: (Clinic & { distance?: number })[];
   lastDoc: any;
 }> {
   try {
-    console.log("[CLINIC_SERVICE] Starting clinic filtering with multiple strategies");
-    
+    console.log('[CLINIC_SERVICE] Starting clinic filtering with multiple strategies');
+
     // Geo query debug i validacija
     if (filters.center && filters.radiusInKm) {
       console.log('[CLINIC_SERVICE] Executing geo query:', {
         center: filters.center,
         radius: filters.radiusInKm,
-        serviceName: 'ClinicService'
+        serviceName: 'ClinicService',
       });
-      
+
       // Validacija location podataka
       if (!filters.center.latitude || !filters.center.longitude) {
         console.warn('[CLINIC_SERVICE] Invalid location data:', filters.center);
@@ -60,39 +60,95 @@ export async function getClinicsByFilters(
       }
     }
 
+    // Strategy 0: Geohash-bounds prefilter + in-memory refinement when geo radius is provided
+    if (filters.center && filters.radiusInKm) {
+      try {
+        console.log('[CLINIC_SERVICE] Strategy 0: Geohash bounds prefilter');
+        const bounds = geohashQueryBounds(
+          [filters.center.latitude, filters.center.longitude],
+          (filters.radiusInKm || 0) * 1000,
+        );
+
+        const collected: Clinic[] = [];
+        for (const b of bounds) {
+          const constraints: QueryConstraint[] = [
+            where('location.geohash', '>=', b[0]),
+            where('location.geohash', '<=', b[1]),
+            where('isActive', '==', filters.isActive ?? true),
+          ];
+
+          // Single tag in query if provided; remaining tag logic is applied in-memory
+          if (filters.tags && filters.tags.length > 0) {
+            constraints.push(where('tags', 'array-contains', filters.tags[0]));
+          }
+
+          const q0 = query(collection(db, CLINICS_COLLECTION), ...constraints);
+          const snap = await getDocs(q0);
+          snap.docs.forEach((d) => collected.push({ ...(d.data() as Clinic), id: d.id }));
+        }
+
+        // Deduplicate
+        const uniqueMap = new Map<string, Clinic>();
+        for (const c of collected) {
+          uniqueMap.set(c.id, c);
+        }
+        let clinics = Array.from(uniqueMap.values());
+
+        // Apply all remaining filters and compute exact distance + sorting
+        clinics = applyInMemoryFilters(clinics, filters);
+
+        // Manual pagination over materialized results
+        const pageSize = filters.pagination || 5;
+        let startIndex = 0;
+        if (filters.lastDoc && typeof filters.lastDoc === 'object' && (filters.lastDoc as any).id) {
+          const idx = clinics.findIndex((c) => c.id === (filters.lastDoc as any).id);
+          if (idx >= 0) startIndex = idx + 1;
+        }
+        const page = clinics.slice(startIndex, startIndex + pageSize);
+        const newLastDoc = page.length === pageSize ? page[page.length - 1] : null;
+
+        console.log(
+          `[CLINIC_SERVICE] Strategy 0 success: ${page.length} clinics (of ${clinics.length})`,
+        );
+        return { clinics: page, lastDoc: newLastDoc };
+      } catch (geoErr) {
+        console.log('[CLINIC_SERVICE] Strategy 0 failed:', geoErr);
+      }
+    }
+
     // Base constraints function (used in all strategies)
     const getBaseConstraints = () => {
       const constraints: QueryConstraint[] = [];
-      constraints.push(where("isActive", "==", filters.isActive ?? true));
-      
+      constraints.push(where('isActive', '==', filters.isActive ?? true));
+
       // Tag (only first, due to Firestore limitation)
       if (filters.tags && filters.tags.length > 0) {
-        constraints.push(where("tags", "array-contains", filters.tags[0]));
+        constraints.push(where('tags', 'array-contains', filters.tags[0]));
       }
-      
+
       // Rating filters
       if (filters.minRating !== undefined) {
-        constraints.push(where("reviewInfo.averageRating", ">=", filters.minRating));
+        constraints.push(where('reviewInfo.averageRating', '>=', filters.minRating));
       }
       if (filters.maxRating !== undefined) {
-        constraints.push(where("reviewInfo.averageRating", "<=", filters.maxRating));
+        constraints.push(where('reviewInfo.averageRating', '<=', filters.maxRating));
       }
-      
+
       return constraints;
     };
 
     // Strategy 1: Try nameLower search if nameSearch exists
     if (filters.nameSearch && filters.nameSearch.trim()) {
       try {
-        console.log("[CLINIC_SERVICE] Strategy 1: Trying nameLower search");
+        console.log('[CLINIC_SERVICE] Strategy 1: Trying nameLower search');
         const searchTerm = filters.nameSearch.trim().toLowerCase();
         const constraints = getBaseConstraints();
-        constraints.push(where("nameLower", ">=", searchTerm));
-        constraints.push(where("nameLower", "<=", searchTerm + "\uf8ff"));
-        constraints.push(orderBy("nameLower"));
+        constraints.push(where('nameLower', '>=', searchTerm));
+        constraints.push(where('nameLower', '<=', searchTerm + '\uf8ff'));
+        constraints.push(orderBy('nameLower'));
 
         if (filters.lastDoc) {
-          if (typeof filters.lastDoc.data === "function") {
+          if (typeof filters.lastDoc.data === 'function') {
             constraints.push(startAfter(filters.lastDoc));
           } else if (Array.isArray(filters.lastDoc)) {
             constraints.push(startAfter(...filters.lastDoc));
@@ -104,37 +160,38 @@ export async function getClinicsByFilters(
 
         const q = query(collection(db, CLINICS_COLLECTION), ...constraints);
         const querySnapshot = await getDocs(q);
-        let clinics = querySnapshot.docs.map(doc => ({ ...doc.data(), id: doc.id } as Clinic));
-        
+        let clinics = querySnapshot.docs.map((doc) => ({ ...doc.data(), id: doc.id } as Clinic));
+
         // Apply in-memory filters
         clinics = applyInMemoryFilters(clinics, filters);
-        
-        const lastDoc = querySnapshot.docs.length > 0 ? querySnapshot.docs[querySnapshot.docs.length - 1] : null;
-        
+
+        const lastDoc =
+          querySnapshot.docs.length > 0 ? querySnapshot.docs[querySnapshot.docs.length - 1] : null;
+
         console.log(`[CLINIC_SERVICE] Strategy 1 success: ${clinics.length} clinics`);
-        
+
         // Fix Load More - ako je broj rezultata manji od pagination, nema više
         if (clinics.length < (filters.pagination || 5)) {
           return { clinics, lastDoc: null };
         }
         return { clinics, lastDoc };
       } catch (error) {
-        console.log("[CLINIC_SERVICE] Strategy 1 failed:", error);
+        console.log('[CLINIC_SERVICE] Strategy 1 failed:', error);
       }
     }
 
     // Strategy 2: Try name field search as fallback
     if (filters.nameSearch && filters.nameSearch.trim()) {
       try {
-        console.log("[CLINIC_SERVICE] Strategy 2: Trying name field search");
+        console.log('[CLINIC_SERVICE] Strategy 2: Trying name field search');
         const searchTerm = filters.nameSearch.trim().toLowerCase();
         const constraints = getBaseConstraints();
-        constraints.push(where("name", ">=", searchTerm));
-        constraints.push(where("name", "<=", searchTerm + "\uf8ff"));
-        constraints.push(orderBy("name"));
+        constraints.push(where('name', '>=', searchTerm));
+        constraints.push(where('name', '<=', searchTerm + '\uf8ff'));
+        constraints.push(orderBy('name'));
 
         if (filters.lastDoc) {
-          if (typeof filters.lastDoc.data === "function") {
+          if (typeof filters.lastDoc.data === 'function') {
             constraints.push(startAfter(filters.lastDoc));
           } else if (Array.isArray(filters.lastDoc)) {
             constraints.push(startAfter(...filters.lastDoc));
@@ -146,33 +203,36 @@ export async function getClinicsByFilters(
 
         const q = query(collection(db, CLINICS_COLLECTION), ...constraints);
         const querySnapshot = await getDocs(q);
-        let clinics = querySnapshot.docs.map(doc => ({ ...doc.data(), id: doc.id } as Clinic));
-        
+        let clinics = querySnapshot.docs.map((doc) => ({ ...doc.data(), id: doc.id } as Clinic));
+
         // Apply in-memory filters
         clinics = applyInMemoryFilters(clinics, filters);
-        
-        const lastDoc = querySnapshot.docs.length > 0 ? querySnapshot.docs[querySnapshot.docs.length - 1] : null;
-        
+
+        const lastDoc =
+          querySnapshot.docs.length > 0 ? querySnapshot.docs[querySnapshot.docs.length - 1] : null;
+
         console.log(`[CLINIC_SERVICE] Strategy 2 success: ${clinics.length} clinics`);
-        
+
         // Fix Load More - ako je broj rezultata manji od pagination, nema više
         if (clinics.length < (filters.pagination || 5)) {
           return { clinics, lastDoc: null };
         }
         return { clinics, lastDoc };
       } catch (error) {
-        console.log("[CLINIC_SERVICE] Strategy 2 failed:", error);
+        console.log('[CLINIC_SERVICE] Strategy 2 failed:', error);
       }
     }
 
     // Strategy 3: createdAt ordering with client-side name filtering
     try {
-      console.log("[CLINIC_SERVICE] Strategy 3: Using createdAt ordering with client-side filtering");
+      console.log(
+        '[CLINIC_SERVICE] Strategy 3: Using createdAt ordering with client-side filtering',
+      );
       const constraints = getBaseConstraints();
-      constraints.push(orderBy("createdAt", "desc"));
+      constraints.push(orderBy('createdAt', 'desc'));
 
       if (filters.lastDoc) {
-        if (typeof filters.lastDoc.data === "function") {
+        if (typeof filters.lastDoc.data === 'function') {
           constraints.push(startAfter(filters.lastDoc));
         } else if (Array.isArray(filters.lastDoc)) {
           constraints.push(startAfter(...filters.lastDoc));
@@ -184,59 +244,60 @@ export async function getClinicsByFilters(
 
       const q = query(collection(db, CLINICS_COLLECTION), ...constraints);
       const querySnapshot = await getDocs(q);
-      let clinics = querySnapshot.docs.map(doc => ({ ...doc.data(), id: doc.id } as Clinic));
+      let clinics = querySnapshot.docs.map((doc) => ({ ...doc.data(), id: doc.id } as Clinic));
 
       // Apply in-memory filters (includes name search)
       clinics = applyInMemoryFilters(clinics, filters);
-      
-      const lastDoc = querySnapshot.docs.length > 0 ? querySnapshot.docs[querySnapshot.docs.length - 1] : null;
-      
+
+      const lastDoc =
+        querySnapshot.docs.length > 0 ? querySnapshot.docs[querySnapshot.docs.length - 1] : null;
+
       console.log(`[CLINIC_SERVICE] Strategy 3 success: ${clinics.length} clinics`);
-      
+
       // Fix Load More - ako je broj rezultata manji od pagination, nema više
       if (clinics.length < (filters.pagination || 5)) {
         return { clinics, lastDoc: null };
       }
       return { clinics, lastDoc };
     } catch (error) {
-      console.log("[CLINIC_SERVICE] Strategy 3 failed:", error);
+      console.log('[CLINIC_SERVICE] Strategy 3 failed:', error);
     }
 
     // Strategy 4: Minimal fallback query
     try {
-      console.log("[CLINIC_SERVICE] Strategy 4: Minimal fallback");
+      console.log('[CLINIC_SERVICE] Strategy 4: Minimal fallback');
       const constraints: QueryConstraint[] = [
-        where("isActive", "==", true),
-        orderBy("createdAt", "desc"),
-        limit(filters.pagination || 5)
+        where('isActive', '==', true),
+        orderBy('createdAt', 'desc'),
+        limit(filters.pagination || 5),
       ];
 
       const q = query(collection(db, CLINICS_COLLECTION), ...constraints);
       const querySnapshot = await getDocs(q);
-      let clinics = querySnapshot.docs.map(doc => ({ ...doc.data(), id: doc.id } as Clinic));
+      let clinics = querySnapshot.docs.map((doc) => ({ ...doc.data(), id: doc.id } as Clinic));
 
       // Apply in-memory filters (includes name search)
       clinics = applyInMemoryFilters(clinics, filters);
-      
-      const lastDoc = querySnapshot.docs.length > 0 ? querySnapshot.docs[querySnapshot.docs.length - 1] : null;
-      
+
+      const lastDoc =
+        querySnapshot.docs.length > 0 ? querySnapshot.docs[querySnapshot.docs.length - 1] : null;
+
       console.log(`[CLINIC_SERVICE] Strategy 4 success: ${clinics.length} clinics`);
-      
+
       // Fix Load More - ako je broj rezultata manji od pagination, nema više
       if (clinics.length < (filters.pagination || 5)) {
         return { clinics, lastDoc: null };
       }
       return { clinics, lastDoc };
     } catch (error) {
-      console.log("[CLINIC_SERVICE] Strategy 4 failed:", error);
+      console.log('[CLINIC_SERVICE] Strategy 4 failed:', error);
     }
 
     // All strategies failed
-    console.log("[CLINIC_SERVICE] All strategies failed, returning empty result");
+    console.log('[CLINIC_SERVICE] All strategies failed, returning empty result');
     return { clinics: [], lastDoc: null };
-
   } catch (error) {
-    console.error("[CLINIC_SERVICE] Error filtering clinics:", error);
+    console.error('[CLINIC_SERVICE] Error filtering clinics:', error);
     return { clinics: [], lastDoc: null };
   }
 }
@@ -247,112 +308,135 @@ export async function getClinicsByFilters(
 function applyInMemoryFilters(clinics: Clinic[], filters: any): (Clinic & { distance?: number })[] {
   let filteredClinics = [...clinics]; // Kreiraj kopiju
 
-  console.log(`[CLINIC_SERVICE] Applying in-memory filters - input: ${filteredClinics.length} clinics`);
-  
+  console.log(
+    `[CLINIC_SERVICE] Applying in-memory filters - input: ${filteredClinics.length} clinics`,
+  );
+
   // ✅ Multi-tag filter (postojeći kod)
   if (filters.tags && filters.tags.length > 1) {
     const initialCount = filteredClinics.length;
-    filteredClinics = filteredClinics.filter(clinic => 
-      filters.tags.every((tag: ClinicTag) => clinic.tags.includes(tag))
+    filteredClinics = filteredClinics.filter((clinic) =>
+      filters.tags.every((tag: ClinicTag) => clinic.tags.includes(tag)),
+    );
+    console.log(
+      `[CLINIC_SERVICE] Applied multi-tag filter: ${initialCount} → ${filteredClinics.length}`,
     );
-    console.log(`[CLINIC_SERVICE] Applied multi-tag filter: ${initialCount} → ${filteredClinics.length}`);
   }
 
   // 🆕 DODAJTE: Single tag filter (za Strategy 4 fallback)
   if (filters.tags && filters.tags.length === 1) {
     const initialCount = filteredClinics.length;
-    filteredClinics = filteredClinics.filter(clinic => 
-      clinic.tags.includes(filters.tags[0])
+    filteredClinics = filteredClinics.filter((clinic) => clinic.tags.includes(filters.tags[0]));
+    console.log(
+      `[CLINIC_SERVICE] Applied single-tag filter: ${initialCount} → ${filteredClinics.length}`,
     );
-    console.log(`[CLINIC_SERVICE] Applied single-tag filter: ${initialCount} → ${filteredClinics.length}`);
   }
 
   // 🆕 DODAJTE: Rating filter
   if (filters.minRating !== undefined || filters.maxRating !== undefined) {
     const initialCount = filteredClinics.length;
-    filteredClinics = filteredClinics.filter(clinic => {
+    filteredClinics = filteredClinics.filter((clinic) => {
       const rating = clinic.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(`[CLINIC_SERVICE] Applied rating filter (${filters.minRating}-${filters.maxRating}): ${initialCount} → ${filteredClinics.length}`);
+    console.log(
+      `[CLINIC_SERVICE] Applied rating filter (${filters.minRating}-${filters.maxRating}): ${initialCount} → ${filteredClinics.length}`,
+    );
   }
 
   // 🆕 DODAJTE: Name search filter
   if (filters.nameSearch && filters.nameSearch.trim()) {
     const initialCount = filteredClinics.length;
     const searchTerm = filters.nameSearch.trim().toLowerCase();
-    filteredClinics = filteredClinics.filter(clinic => {
+    filteredClinics = filteredClinics.filter((clinic) => {
       const name = (clinic.name || '').toLowerCase();
       const nameLower = clinic.nameLower || '';
       return name.includes(searchTerm) || nameLower.includes(searchTerm);
     });
-    console.log(`[CLINIC_SERVICE] Applied name search filter: ${initialCount} → ${filteredClinics.length}`);
+    console.log(
+      `[CLINIC_SERVICE] Applied name search filter: ${initialCount} → ${filteredClinics.length}`,
+    );
   }
 
   // 🆕 DODAJTE: Procedure family filtering
   if (filters.procedureFamily) {
     const initialCount = filteredClinics.length;
-    filteredClinics = filteredClinics.filter(clinic => {
+    filteredClinics = filteredClinics.filter((clinic) => {
       const proceduresInfo = clinic.proceduresInfo || [];
-      return proceduresInfo.some(proc => proc.family === filters.procedureFamily);
+      return proceduresInfo.some((proc) => proc.family === filters.procedureFamily);
     });
-    console.log(`[CLINIC_SERVICE] Applied procedure family filter: ${initialCount} → ${filteredClinics.length}`);
+    console.log(
+      `[CLINIC_SERVICE] Applied procedure family filter: ${initialCount} → ${filteredClinics.length}`,
+    );
   }
 
   // 🆕 DODAJTE: Procedure category filtering
   if (filters.procedureCategory) {
     const initialCount = filteredClinics.length;
-    filteredClinics = filteredClinics.filter(clinic => {
+    filteredClinics = filteredClinics.filter((clinic) => {
       const proceduresInfo = clinic.proceduresInfo || [];
-      return proceduresInfo.some(proc => proc.categoryName === filters.procedureCategory);
+      return proceduresInfo.some((proc) => proc.categoryName === filters.procedureCategory);
     });
-    console.log(`[CLINIC_SERVICE] Applied procedure category filter: ${initialCount} → ${filteredClinics.length}`);
+    console.log(
+      `[CLINIC_SERVICE] Applied procedure category filter: ${initialCount} → ${filteredClinics.length}`,
+    );
   }
 
   // 🆕 DODAJTE: Procedure subcategory filtering
   if (filters.procedureSubcategory) {
     const initialCount = filteredClinics.length;
-    filteredClinics = filteredClinics.filter(clinic => {
+    filteredClinics = filteredClinics.filter((clinic) => {
       const proceduresInfo = clinic.proceduresInfo || [];
-      return proceduresInfo.some(proc => proc.subcategoryName === filters.procedureSubcategory);
+      return proceduresInfo.some((proc) => proc.subcategoryName === filters.procedureSubcategory);
     });
-    console.log(`[CLINIC_SERVICE] Applied procedure subcategory filter: ${initialCount} → ${filteredClinics.length}`);
+    console.log(
+      `[CLINIC_SERVICE] Applied procedure subcategory filter: ${initialCount} → ${filteredClinics.length}`,
+    );
   }
 
   // 🆕 DODAJTE: Procedure technology filtering
   if (filters.procedureTechnology) {
     const initialCount = filteredClinics.length;
-    filteredClinics = filteredClinics.filter(clinic => {
+    filteredClinics = filteredClinics.filter((clinic) => {
       const proceduresInfo = clinic.proceduresInfo || [];
-      return proceduresInfo.some(proc => proc.technologyName === filters.procedureTechnology);
+      return proceduresInfo.some((proc) => proc.technologyName === filters.procedureTechnology);
     });
-    console.log(`[CLINIC_SERVICE] Applied procedure technology filter: ${initialCount} → ${filteredClinics.length}`);
+    console.log(
+      `[CLINIC_SERVICE] Applied procedure technology filter: ${initialCount} → ${filteredClinics.length}`,
+    );
   }
 
   // ✅ Geo-radius filter (postojeći kod)
   if (filters.center && filters.radiusInKm) {
     const initialCount = filteredClinics.length;
-    filteredClinics = filteredClinics.filter(clinic => {
+    filteredClinics = filteredClinics.filter((clinic) => {
       if (!clinic.location?.latitude || !clinic.location?.longitude) {
         console.log(`[CLINIC_SERVICE] Clinic ${clinic.id} missing location data`);
         return false;
       }
-      
-      const distance = distanceBetween(
-        [filters.center.latitude, filters.center.longitude],
-        [clinic.location.latitude, clinic.location.longitude]
-      ) / 1000; // Convert to km
-      
-      console.log(`[CLINIC_SERVICE] Clinic ${clinic.name}: distance ${distance.toFixed(2)}km (limit: ${filters.radiusInKm}km)`);
-      
+
+      const distance =
+        distanceBetween(
+          [filters.center.latitude, filters.center.longitude],
+          [clinic.location.latitude, clinic.location.longitude],
+        ) / 1000; // Convert to km
+
+      console.log(
+        `[CLINIC_SERVICE] Clinic ${clinic.name}: distance ${distance.toFixed(2)}km (limit: ${
+          filters.radiusInKm
+        }km)`,
+      );
+
       // Attach distance for frontend sorting/display
       (clinic as any).distance = distance;
       return distance <= filters.radiusInKm;
     });
-    console.log(`[CLINIC_SERVICE] Applied geo filter (${filters.radiusInKm}km): ${initialCount} → ${filteredClinics.length}`);
-    
+    console.log(
+      `[CLINIC_SERVICE] Applied geo filter (${filters.radiusInKm}km): ${initialCount} → ${filteredClinics.length}`,
+    );
+
     // Sort by distance when geo filtering is applied
     filteredClinics.sort((a, b) => ((a as any).distance || 0) - ((b as any).distance || 0));
   }

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

@@ -1215,6 +1215,37 @@ export class PractitionerService extends BaseService {
         console.log("[PRACTITIONER_SERVICE] Strategy 3 failed:", error);
       }
 
+      // Strategy 4: Client-side filtering fallback (kao u procedure/clinic services)
+      try {
+        console.log("[PRACTITIONER_SERVICE] Strategy 4: Client-side filtering fallback");
+        
+        const constraints: any[] = [
+          where("isActive", "==", true),
+          where("status", "==", PractitionerStatus.ACTIVE),
+          orderBy("createdAt", "desc"),
+          limit(filters.pagination || 10)
+        ];
+
+        const q = query(collection(this.db, PRACTITIONERS_COLLECTION), ...constraints);
+        const querySnapshot = await getDocs(q);
+        let practitioners = querySnapshot.docs.map(doc => ({ ...doc.data(), id: doc.id } as Practitioner));
+
+        // 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 4 success: ${practitioners.length} practitioners`);
+        
+        // Fix Load More - ako je broj rezultata manji od pagination, nema više
+        if (practitioners.length < (filters.pagination || 10)) {
+          return { practitioners, lastDoc: null };
+        }
+        return { practitioners, lastDoc };
+        
+      } catch (error) {
+        console.log("[PRACTITIONER_SERVICE] Strategy 4 failed:", error);
+      }
+
       // All strategies failed
       console.log("[PRACTITIONER_SERVICE] All strategies failed, returning empty result");
       return { practitioners: [], lastDoc: null };