@blackcode_sa/metaestetics-api 1.8.14 → 1.8.16

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

@@ -1043,102 +1043,298 @@ export class PractitionerService extends BaseService {
     includeDraftPractitioners?: boolean;
   }): Promise<{ practitioners: Practitioner[]; lastDoc: any }> {
     try {
-      // 1. Prepare Firestore constraints
-      const constraints: any[] = [];
-      if (!filters.includeDraftPractitioners) {
-        constraints.push(where("status", "==", PractitionerStatus.ACTIVE));
-      }
-      constraints.push(where("isActive", "==", true));
-
-      // Certifications
-      if (filters.certifications && filters.certifications.length > 0) {
-        constraints.push(
-          where(
-            "certification.certifications",
-            "array-contains-any",
-            filters.certifications
-          )
-        );
+      console.log("[PRACTITIONER_SERVICE] Starting practitioner filtering with fallback strategies");
+
+      // Geo query debug i validacija
+      if (filters.location && filters.radiusInKm) {
+        console.log('[PRACTITIONER_SERVICE] Executing geo query:', {
+          location: filters.location,
+          radius: filters.radiusInKm,
+          serviceName: 'PractitionerService'
+        });
+        
+        // Validacija location podataka
+        if (!filters.location.latitude || !filters.location.longitude) {
+          console.warn('[PRACTITIONER_SERVICE] Invalid location data:', filters.location);
+          filters.location = undefined;
+          filters.radiusInKm = undefined;
+        }
       }
 
-      // Text search by fullNameLower
+      // Strategy 1: Try fullNameLower search if nameSearch exists
       if (filters.nameSearch && filters.nameSearch.trim()) {
-        const searchTerm = filters.nameSearch.trim().toLowerCase();
-        constraints.push(where("fullNameLower", ">=", searchTerm));
-        constraints.push(where("fullNameLower", "<=", searchTerm + "\uf8ff"));
+        try {
+          console.log("[PRACTITIONER_SERVICE] Strategy 1: Trying fullNameLower search");
+          const searchTerm = filters.nameSearch.trim().toLowerCase();
+          const constraints: any[] = [];
+          
+          if (!filters.includeDraftPractitioners) {
+            constraints.push(where("status", "==", PractitionerStatus.ACTIVE));
+          }
+          constraints.push(where("isActive", "==", true));
+          constraints.push(where("fullNameLower", ">=", searchTerm));
+          constraints.push(where("fullNameLower", "<=", searchTerm + "\uf8ff"));
+          constraints.push(orderBy("fullNameLower"));
+
+          if (filters.lastDoc) {
+            if (typeof filters.lastDoc.data === "function") {
+              constraints.push(startAfter(filters.lastDoc));
+            } else if (Array.isArray(filters.lastDoc)) {
+              constraints.push(startAfter(...filters.lastDoc));
+            } else {
+              constraints.push(startAfter(filters.lastDoc));
+            }
+          }
+          constraints.push(limit(filters.pagination || 10));
+
+          const q = query(collection(this.db, PRACTITIONERS_COLLECTION), ...constraints);
+          const querySnapshot = await getDocs(q);
+          const practitioners = querySnapshot.docs.map(doc => ({ ...doc.data(), id: doc.id } as Practitioner));
+          const lastDoc = querySnapshot.docs.length > 0 ? querySnapshot.docs[querySnapshot.docs.length - 1] : null;
+          
+          console.log(`[PRACTITIONER_SERVICE] Strategy 1 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 1 failed:", error);
+        }
       }
 
-      // Procedure filters (if mapped to fields)
-      if (filters.procedureTechnology) {
-        constraints.push(where("proceduresInfo.technologyName", "==", filters.procedureTechnology));
-      } else if (filters.procedureSubcategory) {
-        constraints.push(where("proceduresInfo.subcategoryName", "==", filters.procedureSubcategory));
-      } else if (filters.procedureCategory) {
-        constraints.push(where("proceduresInfo.categoryName", "==", filters.procedureCategory));
-      } else if (filters.procedureFamily) {
-        constraints.push(where("proceduresInfo.family", "==", filters.procedureFamily));
-      }
+      // Strategy 2: Basic query with createdAt ordering (no name search)
+      try {
+        console.log("[PRACTITIONER_SERVICE] Strategy 2: Basic query with createdAt ordering");
+        const constraints: any[] = [];
+        
+        if (!filters.includeDraftPractitioners) {
+          constraints.push(where("status", "==", PractitionerStatus.ACTIVE));
+        }
+        constraints.push(where("isActive", "==", true));
 
-      // Rating filters
-      if (filters.minRating !== undefined) {
-        constraints.push(where("reviewInfo.averageRating", ">=", filters.minRating));
-      }
-      if (filters.maxRating !== undefined) {
-        constraints.push(where("reviewInfo.averageRating", "<=", filters.maxRating));
-      }
+        // 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", certificationsToMatch)
+          );
+        }
+
+        if (filters.minRating !== undefined) {
+          constraints.push(where("reviewInfo.averageRating", ">=", filters.minRating));
+        }
+        if (filters.maxRating !== undefined) {
+          constraints.push(where("reviewInfo.averageRating", "<=", filters.maxRating));
+        }
 
-      // Pagination and ordering
-      constraints.push(orderBy("fullNameLower"));
-      if (filters.lastDoc) {
-        if (typeof filters.lastDoc.data === "function") {
-          constraints.push(startAfter(filters.lastDoc));
-        } else if (Array.isArray(filters.lastDoc)) {
-          constraints.push(startAfter(...filters.lastDoc));
+        constraints.push(orderBy("createdAt", "desc"));
+
+        // Pagination sa createdAt - poboljšano za geo queries
+        if (filters.location && filters.radiusInKm) {
+          // Ne koristiti lastDoc za geo queries, već preuzmi više rezultata
+          constraints.push(limit((filters.pagination || 10) * 2)); // Dvostruko više za geo filter
         } else {
-          constraints.push(startAfter(filters.lastDoc));
+          if (filters.lastDoc) {
+            if (typeof filters.lastDoc.data === "function") {
+              constraints.push(startAfter(filters.lastDoc));
+            } else if (Array.isArray(filters.lastDoc)) {
+              constraints.push(startAfter(...filters.lastDoc));
+            } else {
+              constraints.push(startAfter(filters.lastDoc));
+            }
+          }
+          constraints.push(limit(filters.pagination || 10));
         }
-      }
-      constraints.push(limit(filters.pagination || 5));
 
-      // 2. Firestore query
-      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));
-
-      // 3. In-memory filter ONLY for geo-radius (if needed)
-      if (filters.location && filters.radiusInKm && filters.radiusInKm > 0) {
-        const location = filters.location;
-        const radiusInKm = filters.radiusInKm;
-        practitioners = practitioners.filter((practitioner) => {
-          // Use the aggregated clinicsInfo to check if any clinic is within range
-          const clinics = practitioner.clinicsInfo || [];
-          return clinics.some((clinic) => {
-            // Calculate distance
-            const distance = distanceBetween(
-              [location.latitude, location.longitude],
-              [clinic.location.latitude, clinic.location.longitude]
-            );
-            // Convert to kilometers
-            const distanceInKm = distance / 1000;
-            // Check if within radius
-            return distanceInKm <= radiusInKm;
+        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 geo filter if needed (this is the only in-memory filter we keep)
+        if (filters.location && filters.radiusInKm && filters.radiusInKm > 0) {
+          const location = filters.location;
+          const radiusInKm = filters.radiusInKm;
+          practitioners = practitioners.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;
+            });
           });
-        });
+          
+          // Ograniči na pagination broj nakon geo filtera
+          practitioners = practitioners.slice(0, filters.pagination || 10);
+        }
+
+        // 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`);
+        
+        // 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 2 failed:", error);
       }
 
-      // 4. Return results and lastDoc
-      const lastDoc = querySnapshot.docs.length > 0 ? querySnapshot.docs[querySnapshot.docs.length - 1] : null;
-      return {
-        practitioners,
-        lastDoc,
-      };
+      // Strategy 3: Minimal query fallback
+      try {
+        console.log("[PRACTITIONER_SERVICE] Strategy 3: Minimal query fallback");
+        const constraints: any[] = [
+          where("isActive", "==", true),
+          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 3 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 3 failed:", error);
+      }
+
+      // All strategies failed
+      console.log("[PRACTITIONER_SERVICE] All strategies failed, returning empty result");
+      return { practitioners: [], lastDoc: null };
+
     } catch (error) {
-      console.error(
-        "[PRACTITIONER_SERVICE] Error filtering practitioners:",
-        error
-      );
-      throw error;
+      console.error("[PRACTITIONER_SERVICE] Error filtering practitioners:", error);
+      return { practitioners: [], lastDoc: null };
+    }
+  }
+
+  /**
+   * 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;
   }
 
   /**