@blackcode_sa/metaestetics-api 1.8.12 → 1.8.13

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

@@ -32,6 +32,7 @@ export async function getClinicsByFilters(
     procedureTechnology?: string;
     minRating?: number;
     maxRating?: number;
+    nameSearch?: string;
     pagination?: number;
     lastDoc?: any;
     isActive?: boolean;
@@ -40,251 +41,79 @@ export async function getClinicsByFilters(
   clinics: (Clinic & { distance?: number })[];
   lastDoc: any;
 }> {
-  console.log(
-    "[FILTER_UTILS] Starting clinic filtering with criteria:",
-    filters
-  );
-
-  // Determine if we're doing a geo query or a regular query
-  const isGeoQuery =
-    filters.center && filters.radiusInKm && filters.radiusInKm > 0;
-
-  // Initialize base constraints
+  // 1. Prepare Firestore constraints
   const constraints: QueryConstraint[] = [];
+  constraints.push(where("isActive", "==", filters.isActive ?? true));
 
-  // 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));
-  }
-
-  // Add tag filtering if specified
+  // Tag (only first, Firestore limitation)
   if (filters.tags && filters.tags.length > 0) {
-    // Note: We can only use array-contains-any once per query, so we're selecting one tag
-    // for the query and we'll filter the remaining tags in memory
     constraints.push(where("tags", "array-contains", filters.tags[0]));
   }
 
-  // Hierarchical procedure filter - only apply the most specific one provided
-  // Order of specificity: technology > subcategory > category > family
+  // Procedure filters (most specific)
   if (filters.procedureTechnology) {
-    constraints.push(
-      where("servicesInfo.technology", "==", filters.procedureTechnology)
-    );
+    constraints.push(where("servicesInfo.technology", "==", filters.procedureTechnology));
   } else if (filters.procedureSubcategory) {
-    constraints.push(
-      where("servicesInfo.subCategory", "==", filters.procedureSubcategory)
-    );
+    constraints.push(where("servicesInfo.subCategory", "==", filters.procedureSubcategory));
   } else if (filters.procedureCategory) {
-    constraints.push(
-      where("servicesInfo.category", "==", filters.procedureCategory)
-    );
+    constraints.push(where("servicesInfo.category", "==", filters.procedureCategory));
   } else if (filters.procedureFamily) {
-    constraints.push(
-      where("servicesInfo.procedureFamily", "==", filters.procedureFamily)
-    );
+    constraints.push(where("servicesInfo.procedureFamily", "==", filters.procedureFamily));
   }
 
-  // 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));
+  // Text search by nameLower
+  let useNameLower = false;
+  let searchTerm = "";
+  if (filters.nameSearch && filters.nameSearch.trim()) {
+    searchTerm = filters.nameSearch.trim().toLowerCase();
+    constraints.push(where("nameLower", ">=", searchTerm));
+    constraints.push(where("nameLower", "<=", searchTerm + "\uf8ff"));
+    useNameLower = true;
   }
 
-  // Add ordering to make pagination consistent
-  constraints.push(orderBy("location.geohash"));
-
-  let clinicsResult: (Clinic & { distance?: number })[] = [];
-  let lastVisibleDoc = null;
-
-  // For geo queries, we need a different approach
-  if (isGeoQuery) {
-    const center = filters.center!;
-    const radiusInKm = filters.radiusInKm!;
-
-    // Get the geohash query bounds
-    const bounds = geohashQueryBounds(
-      [center.latitude, center.longitude],
-      radiusInKm * 1000 // Convert to meters
-    );
-
-    // Collect matching clinics from all bounds
-    const matchingClinics: (Clinic & { distance: number })[] = [];
-
-    // Execute queries for each bound
-    for (const bound of bounds) {
-      // Create a geo query for this bound
-      const geoConstraints = [
-        ...constraints,
-        where("location.geohash", ">=", bound[0]),
-        where("location.geohash", "<=", bound[1]),
-      ];
-
-      const q = query(collection(db, CLINICS_COLLECTION), ...geoConstraints);
-      const querySnapshot = await getDocs(q);
-
-      console.log(
-        `[FILTER_UTILS] Found ${querySnapshot.docs.length} clinics in geo bound`
-      );
-
-      // Process results and filter by actual distance
-      for (const doc of querySnapshot.docs) {
-        const clinic = { ...doc.data(), id: doc.id } as Clinic;
-
-        // Calculate actual distance
-        const distance = distanceBetween(
-          [center.latitude, center.longitude],
-          [clinic.location.latitude, clinic.location.longitude]
-        );
-
-        // Convert to kilometers
-        const distanceInKm = distance / 1000;
-
-        // Check if within radius
-        if (distanceInKm <= radiusInKm) {
-          // Add distance to clinic object
-          matchingClinics.push({
-            ...clinic,
-            distance: distanceInKm,
-          });
-        }
-      }
-    }
-
-    // Apply additional filters that couldn't be applied in the query
-    let filteredClinics = matchingClinics;
-
-    // Filter by multiple tags if more than one tag was specified
-    if (filters.tags && filters.tags.length > 1) {
-      filteredClinics = filteredClinics.filter((clinic) => {
-        // Check if clinic has all specified tags
-        return filters.tags!.every((tag) => clinic.tags.includes(tag));
-      });
-    }
-
-    // Filter by rating
-    if (filters.minRating !== undefined) {
-      filteredClinics = filteredClinics.filter(
-        (clinic) => clinic.reviewInfo.averageRating >= filters.minRating!
-      );
-    }
-
-    if (filters.maxRating !== undefined) {
-      filteredClinics = filteredClinics.filter(
-        (clinic) => clinic.reviewInfo.averageRating <= filters.maxRating!
-      );
-    }
-
-    // Sort by distance
-    filteredClinics.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 = filteredClinics.findIndex(
-          (clinic) => clinic.id === filters.lastDoc.id
-        );
-        if (lastDocIndex !== -1) {
-          startIndex = lastDocIndex + 1;
-        }
-      }
-
-      // Get paginated subset
-      const paginatedClinics = filteredClinics.slice(
-        startIndex,
-        startIndex + filters.pagination
-      );
-
-      // Set last document for next pagination
-      lastVisibleDoc =
-        paginatedClinics.length > 0
-          ? paginatedClinics[paginatedClinics.length - 1]
-          : null;
+  // Rating filters
+  if (filters.minRating !== undefined) {
+    constraints.push(where("reviewInfo.averageRating", ">=", filters.minRating));
+  }
+  if (filters.maxRating !== undefined) {
+    constraints.push(where("reviewInfo.averageRating", "<=", filters.maxRating));
+  }
 
-      clinicsResult = paginatedClinics;
+  // Pagination and ordering
+  constraints.push(orderBy("nameLower"));
+  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 {
-      clinicsResult = filteredClinics;
+      constraints.push(startAfter(filters.lastDoc));
     }
-  } else {
-    // For non-geo queries, execute a single query with all constraints
-    const q = query(collection(db, CLINICS_COLLECTION), ...constraints);
-    const querySnapshot = await getDocs(q);
+  }
+  constraints.push(limit(filters.pagination || 5));
 
-    console.log(
-      `[FILTER_UTILS] Found ${querySnapshot.docs.length} clinics with regular query`
-    );
+  // 2. Firestore query
+  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));
 
-    // Convert docs to clinics
-    const clinics = querySnapshot.docs.map((doc) => {
-      return { ...doc.data(), id: doc.id } as Clinic;
+  // 3. In-memory filters for multi-tag and geo-radius
+  if (filters.tags && filters.tags.length > 1) {
+    clinics = clinics.filter(clinic => filters.tags!.every(tag => clinic.tags.includes(tag)));
+  }
+  if (filters.center && filters.radiusInKm) {
+    clinics = clinics.filter(clinic => {
+      const distance = distanceBetween(
+        [filters.center!.latitude, filters.center!.longitude],
+        [clinic.location.latitude, clinic.location.longitude]
+      ) / 1000;
+      // Optionally attach distance for frontend
+      (clinic as any).distance = distance;
+      return distance <= filters.radiusInKm!;
     });
-
-    // Apply filters that couldn't be applied in the query
-    let filteredClinics = clinics;
-
-    // Calculate distance for each clinic if center coordinates are provided
-    if (filters.center) {
-      const center = filters.center;
-      const clinicsWithDistance: (Clinic & { distance: number })[] = [];
-
-      filteredClinics.forEach((clinic) => {
-        const distance = distanceBetween(
-          [center.latitude, center.longitude],
-          [clinic.location.latitude, clinic.location.longitude]
-        );
-
-        clinicsWithDistance.push({
-          ...clinic,
-          distance: distance / 1000, // Convert to kilometers
-        });
-      });
-
-      // Replace filtered clinics with the version that includes distances
-      filteredClinics = clinicsWithDistance;
-
-      // Sort by distance - use type assertion to fix type error
-      (filteredClinics as (Clinic & { distance: number })[]).sort(
-        (a, b) => a.distance - b.distance
-      );
-    }
-
-    // Filter by multiple tags if more than one tag was specified
-    if (filters.tags && filters.tags.length > 1) {
-      filteredClinics = filteredClinics.filter((clinic) => {
-        // Check if clinic has all specified tags
-        return filters.tags!.every((tag) => clinic.tags.includes(tag));
-      });
-    }
-
-    // Filter by rating
-    if (filters.minRating !== undefined) {
-      filteredClinics = filteredClinics.filter(
-        (clinic) => clinic.reviewInfo.averageRating >= filters.minRating!
-      );
-    }
-
-    if (filters.maxRating !== undefined) {
-      filteredClinics = filteredClinics.filter(
-        (clinic) => clinic.reviewInfo.averageRating <= filters.maxRating!
-      );
-    }
-
-    // Set last document for pagination
-    lastVisibleDoc =
-      querySnapshot.docs.length > 0
-        ? querySnapshot.docs[querySnapshot.docs.length - 1]
-        : null;
-
-    clinicsResult = filteredClinics;
   }
 
-  return {
-    clinics: clinicsResult,
-    lastDoc: lastVisibleDoc,
-  };
+  // 4. Return results and lastDoc
+  const lastVisibleDoc = querySnapshot.docs.length > 0 ? querySnapshot.docs[querySnapshot.docs.length - 1] : null;
+  return { clinics, lastDoc: lastVisibleDoc };
 }

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

@@ -193,6 +193,7 @@ export class PractitionerService extends BaseService {
       };
 
       // Create practitioner object
+      const fullNameLower = `${validData.basicInfo.firstName} ${validData.basicInfo.lastName}`.toLowerCase();
       const practitioner: Omit<Practitioner, "createdAt" | "updatedAt"> & {
         createdAt: FieldValue;
         updatedAt: FieldValue;
@@ -203,6 +204,7 @@ export class PractitionerService extends BaseService {
           validData.basicInfo,
           practitionerId
         ),
+        fullNameLower: fullNameLower, // Ensure this is present
         certification: validData.certification,
         clinics: validData.clinics || [],
         clinicWorkingHours: validData.clinicWorkingHours || [],
@@ -346,6 +348,8 @@ export class PractitionerService extends BaseService {
 
       const proceduresInfo: ProcedureSummaryInfo[] = [];
 
+      // Add fullNameLower for draft
+      const fullNameLowerDraft = `${validatedData.basicInfo.firstName} ${validatedData.basicInfo.lastName}`.toLowerCase();
       const practitionerData: Omit<Practitioner, "createdAt" | "updatedAt"> & {
         createdAt: ReturnType<typeof serverTimestamp>;
         updatedAt: ReturnType<typeof serverTimestamp>;
@@ -356,6 +360,7 @@ export class PractitionerService extends BaseService {
           validatedData.basicInfo,
           practitionerId
         ),
+        fullNameLower: fullNameLowerDraft, // Ensure this is present
         certification: validatedData.certification,
         clinics: clinics,
         clinicWorkingHours: validatedData.clinicWorkingHours || [],
@@ -1036,22 +1041,14 @@ export class PractitionerService extends BaseService {
     includeDraftPractitioners?: boolean;
   }): Promise<{ practitioners: Practitioner[]; lastDoc: any }> {
     try {
-      console.log(
-        "[PRACTITIONER_SERVICE] Starting practitioner filtering with criteria:",
-        filters
-      );
-
-      const constraints = [];
-
-      // Filter by status if not including drafts
+      // 1. Prepare Firestore constraints
+      const constraints: any[] = [];
       if (!filters.includeDraftPractitioners) {
         constraints.push(where("status", "==", PractitionerStatus.ACTIVE));
       }
-
-      // Filter by active status
       constraints.push(where("isActive", "==", true));
 
-      // Add certifications filter if specified
+      // Certifications
       if (filters.certifications && filters.certifications.length > 0) {
         constraints.push(
           where(
@@ -1062,138 +1059,73 @@ export class PractitionerService extends BaseService {
         );
       }
 
-      // Add ordering for consistent pagination
-      constraints.push(orderBy("basicInfo.lastName", "asc"));
-      constraints.push(orderBy("basicInfo.firstName", "asc"));
-
-      // Add pagination if specified
-      if (filters.pagination && filters.pagination > 0) {
-        if (filters.lastDoc) {
-          constraints.push(startAfter(filters.lastDoc));
-        }
-        constraints.push(limit(filters.pagination));
+      // Text search by fullNameLower
+      if (filters.nameSearch && filters.nameSearch.trim()) {
+        const searchTerm = filters.nameSearch.trim().toLowerCase();
+        constraints.push(where("fullNameLower", ">=", searchTerm));
+        constraints.push(where("fullNameLower", "<=", searchTerm + "\uf8ff"));
       }
 
-      // Execute the query
-      const q = query(
-        collection(this.db, PRACTITIONERS_COLLECTION),
-        ...constraints
-      );
-      const querySnapshot = await getDocs(q);
-
-      console.log(
-        `[PRACTITIONER_SERVICE] Found ${querySnapshot.docs.length} practitioners with base query`
-      );
-
-      // Convert docs to practitioners
-      let practitioners = querySnapshot.docs.map((doc) => {
-        return { ...doc.data(), id: doc.id } as Practitioner;
-      });
-
-      // Get last document for pagination
-      const lastDoc =
-        querySnapshot.docs.length > 0
-          ? querySnapshot.docs[querySnapshot.docs.length - 1]
-          : null;
-
-      // Further filter results in memory
-
-      // Filter by name search if specified
-      if (filters.nameSearch && filters.nameSearch.trim() !== "") {
-        const searchTerm = filters.nameSearch.toLowerCase().trim();
-        practitioners = practitioners.filter((practitioner) => {
-          const fullName =
-            `${practitioner.basicInfo.firstName} ${practitioner.basicInfo.lastName}`.toLowerCase();
-          return fullName.includes(searchTerm);
-        });
+      // 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));
       }
 
-      // Filter by specialties
-      if (filters.specialties && filters.specialties.length > 0) {
-        practitioners = practitioners.filter((practitioner) => {
-          return filters.specialties!.every((specialty) =>
-            practitioner.certification.specialties.includes(specialty)
-          );
-        });
+      // Rating filters
+      if (filters.minRating !== undefined) {
+        constraints.push(where("reviewInfo.averageRating", ">=", filters.minRating));
+      }
+      if (filters.maxRating !== undefined) {
+        constraints.push(where("reviewInfo.averageRating", "<=", filters.maxRating));
       }
 
-      // Filter by procedure attributes using the aggregated proceduresInfo
-      if (
-        filters.procedureTechnology ||
-        filters.procedureSubcategory ||
-        filters.procedureCategory ||
-        filters.procedureFamily
-      ) {
-        practitioners = practitioners.filter((practitioner) => {
-          const procedures = practitioner.proceduresInfo || [];
-          return procedures.some((procedure: ProcedureSummaryInfo) => {
-            // Apply hierarchical filter - most specific first
-            if (filters.procedureTechnology) {
-              return procedure.technologyName === filters.procedureTechnology;
-            }
-            if (filters.procedureSubcategory) {
-              return procedure.subcategoryName === filters.procedureSubcategory;
-            }
-            if (filters.procedureCategory) {
-              return procedure.categoryName === filters.procedureCategory;
-            }
-            if (filters.procedureFamily) {
-              return procedure.family === filters.procedureFamily;
-            }
-            return false;
-          });
-        });
+      // 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));
+        } else {
+          constraints.push(startAfter(filters.lastDoc));
+        }
       }
+      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));
 
-      // Filter by location/distance if specified
+      // 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 || [];
-
-          // Check if any clinic is within the specified radius
           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;
           });
         });
       }
 
-      // Filter by rating
-      if (filters.minRating !== undefined) {
-        practitioners = practitioners.filter(
-          (p) => p.reviewInfo.averageRating >= filters.minRating!
-        );
-      }
-
-      if (filters.maxRating !== undefined) {
-        practitioners = practitioners.filter(
-          (p) => p.reviewInfo.averageRating <= filters.maxRating!
-        );
-      }
-
-      console.log(
-        `[PRACTITIONER_SERVICE] Filtered to ${practitioners.length} practitioners`
-      );
-
-      // Apply pagination after all filters have been applied
-      // This is a secondary pagination for in-memory filtered results
-      if (filters.pagination && filters.pagination > 0) {
-        practitioners = practitioners.slice(0, filters.pagination);
-      }
-
+      // 4. Return results and lastDoc
+      const lastDoc = querySnapshot.docs.length > 0 ? querySnapshot.docs[querySnapshot.docs.length - 1] : null;
       return {
         practitioners,
         lastDoc,

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

@@ -660,7 +660,7 @@ export class ProcedureService extends BaseService {
     // Handle Category/Subcategory/Technology/Product Changes
     let finalCategoryId = existingProcedure.category.id;
     if (validatedData.name) {
-      updatedProcedureData.nameLower = validatedData.nameLower || validatedData.name.toLowerCase();
+      updatedProcedureData.nameLower = validatedData.name.toLowerCase();
     }
     if (validatedData.categoryId) {
       const category = await this.categoryService.getById(
@@ -955,8 +955,17 @@ export class ProcedureService extends BaseService {
         constraints.push(orderBy("nameLower"));
       }
       if (filters.lastDoc) {
-        // lastDoc treba da bude ceo snapshot, ne samo id!
-        constraints.push(startAfter(filters.lastDoc));
+        // Firestore pagination: support both QueryDocumentSnapshot and value arrays
+        if (typeof filters.lastDoc.data === "function") {
+          // QueryDocumentSnapshot
+          constraints.push(startAfter(filters.lastDoc));
+        } else if (Array.isArray(filters.lastDoc)) {
+          // Array of values for multiple orderBy fields
+          constraints.push(startAfter(...filters.lastDoc));
+        } else {
+          // Single value
+          constraints.push(startAfter(filters.lastDoc));
+        }
       }
       if (filters.pagination && filters.pagination > 0) {
         constraints.push(limit(filters.pagination));
@@ -1174,4 +1183,35 @@ export class ProcedureService extends BaseService {
     const savedDoc = await getDoc(procedureRef);
     return savedDoc.data() as Procedure;
   }
+
+  /**
+   * Gets all procedures with minimal info for map display (id, name, clinicId, clinicName, address, latitude, longitude)
+   * This is optimized for mobile map usage to reduce payload size.
+   * @returns Array of minimal procedure info for map
+   */
+  async getProceduresForMap(): Promise<{
+    id: string;
+    name: string;
+    clinicId: string | undefined;
+    clinicName: string | undefined;
+    address: string;
+    latitude: number | undefined;
+    longitude: number | undefined;
+  }[]> {
+    const proceduresRef = collection(this.db, PROCEDURES_COLLECTION);
+    const snapshot = await getDocs(proceduresRef);
+    const proceduresForMap = snapshot.docs.map(doc => {
+      const data = doc.data();
+      return {
+        id: doc.id,
+        name: data.name,
+        clinicId: data.clinicInfo?.id,
+        clinicName: data.clinicInfo?.name,
+        address: data.clinicInfo?.location?.address || '',
+        latitude: data.clinicInfo?.location?.latitude,
+        longitude: data.clinicInfo?.location?.longitude,
+      };
+    });
+    return proceduresForMap;
+  }
 }

package/src/types/clinic/index.ts

@@ -269,6 +269,7 @@ export interface Clinic {
   id: string;
   clinicGroupId: string;
   name: string;
+  nameLower: string; // Add this line
   description?: string;
   location: ClinicLocation;
   contactInfo: ClinicContactInfo;

package/src/types/practitioner/index.ts

@@ -89,6 +89,7 @@ export interface Practitioner {
   id: string;
   userRef: string;
   basicInfo: PractitionerBasicInfo;
+  fullNameLower: string; // Add this line
   certification: PractitionerCertification;
   clinics: string[]; // Reference na klinike gde radi
   clinicWorkingHours: PractitionerClinicWorkingHours[]; // Radno vreme za svaku kliniku