@blackcode_sa/metaestetics-api 1.8.11 → 1.8.13

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

@@ -263,6 +263,7 @@ export class ProcedureService extends BaseService {
     const newProcedure: Omit<Procedure, "createdAt" | "updatedAt"> = {
       id: procedureId,
       ...validatedData,
+      nameLower: validatedData.nameLower || validatedData.name.toLowerCase(),
       photos: processedPhotos,
       category, // Embed full objects
       subcategory,
@@ -430,6 +431,7 @@ export class ProcedureService extends BaseService {
       const newProcedure: Omit<Procedure, "createdAt" | "updatedAt"> = {
         id: procedureId,
         ...validatedData,
+        nameLower: validatedData.nameLower || validatedData.name.toLowerCase(),
         practitionerId: practitionerId, // Override practitionerId with the correct one
         photos: processedPhotos,
         category,
@@ -657,6 +659,9 @@ export class ProcedureService extends BaseService {
 
     // Handle Category/Subcategory/Technology/Product Changes
     let finalCategoryId = existingProcedure.category.id;
+    if (validatedData.name) {
+      updatedProcedureData.nameLower = validatedData.name.toLowerCase();
+    }
     if (validatedData.categoryId) {
       const category = await this.categoryService.getById(
         validatedData.categoryId
@@ -853,6 +858,8 @@ export class ProcedureService extends BaseService {
   /**
    * Searches and filters procedures based on multiple criteria
    *
+   * @note Frontend MORA da šalje ceo snapshot (ili barem sva polja po kojima sortiraš, npr. nameLower) kao lastDoc za paginaciju, a ne samo id!
+   *
    * @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
@@ -892,11 +899,6 @@ export class ProcedureService extends BaseService {
     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;
@@ -915,291 +917,131 @@ export class ProcedureService extends BaseService {
       if (filters.procedureFamily) {
         constraints.push(where("family", "==", filters.procedureFamily));
       }
-
-      // Add ordering to make pagination consistent
-      constraints.push(orderBy("clinicInfo.location.geohash"));
-
-      // 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) {
+      if (filters.procedureCategory) {
+        constraints.push(where("category.id", "==", filters.procedureCategory));
+      }
+      if (filters.procedureSubcategory) {
+        constraints.push(where("subcategory.id", "==", filters.procedureSubcategory));
+      }
+      if (filters.procedureTechnology) {
+        constraints.push(where("technology.id", "==", filters.procedureTechnology));
+      }
+      if (filters.minPrice !== undefined) {
+        constraints.push(where("price", ">=", filters.minPrice));
+      }
+      if (filters.maxPrice !== undefined) {
+        constraints.push(where("price", "<=", filters.maxPrice));
+      }
+      if (filters.minRating !== undefined) {
+        constraints.push(where("reviewInfo.averageRating", ">=", filters.minRating));
+      }
+      if (filters.maxRating !== undefined) {
+        constraints.push(where("reviewInfo.averageRating", "<=", filters.maxRating));
+      }
+      if (filters.treatmentBenefits && filters.treatmentBenefits.length > 0) {
+        // Firestore ne podržava array-contains-all, koristi array-contains-any
+        constraints.push(where("treatmentBenefits", "array-contains-any", filters.treatmentBenefits));
+      }
+      // Text search by name (case-sensitive, Firestore limitation)
+      let useNameLower = false;
+      let searchTerm = "";
+      if (filters.nameSearch && filters.nameSearch.trim() !== "") {
+        searchTerm = filters.nameSearch.trim().toLowerCase();
+        useNameLower = true;
+        constraints.push(where("nameLower", ">=", searchTerm));
+        constraints.push(where("nameLower", "<=", searchTerm + "\uf8ff"));
+        constraints.push(orderBy("nameLower"));
+      } else {
+        constraints.push(orderBy("nameLower"));
+      }
+      if (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));
       }
 
-      let proceduresResult: (Procedure & { distance?: number })[] = [];
-      let lastVisibleDoc = null;
-
-      // For geo queries, we need a different approach
+      // Geo-query: special handling
       if (isGeoQuery) {
+        // For geo queries, use geohash bounds and add all other constraints
         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
+        let allDocs: (Procedure & { distance: number })[] = [];
         for (const bound of bounds) {
-          // Create a geo query for this bound
           const geoConstraints = [
-            ...constraints,
+            ...constraints.filter(c => !(c as any).fieldPath || (c as any).fieldPath !== "name"), // Remove name orderBy for geo
             where("clinicInfo.location.geohash", ">=", bound[0]),
             where("clinicInfo.location.geohash", "<=", bound[1]),
+            orderBy("clinicInfo.location.geohash"),
           ];
-
-          const q = query(
-            collection(this.db, PROCEDURES_COLLECTION),
-            ...geoConstraints
-          );
+          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,
-              ]
+              [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,
-              });
+              allDocs.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
+        allDocs.sort((a, b) => a.distance - b.distance);
+        // Paginate
+        let paginated = allDocs;
         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;
-            }
+            const lastDocIndex = allDocs.findIndex(p => p.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;
+          paginated = allDocs.slice(startIndex, startIndex + filters.pagination);
         }
+        const lastVisibleDoc = paginated.length > 0 ? paginated[paginated.length - 1] : null;
+        return { procedures: paginated, lastDoc: lastVisibleDoc };
       } 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;
-        });
-
-        // Calculate distance for each procedure if location is provided
-        if (filters.location) {
-          const center = filters.location;
-          const proceduresWithDistance: (Procedure & { distance: number })[] =
-            [];
-
-          procedures.forEach((procedure) => {
-            const distance = distanceBetween(
-              [center.latitude, center.longitude],
-              [
-                procedure.clinicInfo.location.latitude,
-                procedure.clinicInfo.location.longitude,
-              ]
-            );
-
-            proceduresWithDistance.push({
-              ...procedure,
-              distance: distance / 1000, // Convert to kilometers
-            });
-          });
-
-          // Replace procedures with version that includes distances
-          let filteredProcedures = proceduresWithDistance;
-
-          // Apply in-memory filters
-          filteredProcedures = this.applyInMemoryFilters(
-            filteredProcedures,
-            filters
-          );
-
-          // Sort by distance
-          filteredProcedures.sort((a, b) => a.distance - b.distance);
-
-          proceduresResult = filteredProcedures;
-        } else {
-          // Apply filters that couldn't be applied in the query
-          let filteredProcedures = this.applyInMemoryFilters(
-            procedures,
-            filters
-          );
-          proceduresResult = filteredProcedures;
+        // Regular query
+        let q = query(collection(this.db, PROCEDURES_COLLECTION), ...constraints);
+        let querySnapshot = await getDocs(q);
+        // Fallback na name ako nema rezultata i koristi se nameLower
+        if (useNameLower && querySnapshot.empty && searchTerm) {
+          // Ukloni poslednja 3 constraints (nameLower >=, nameLower <=, orderBy nameLower)
+          constraints.pop();
+          constraints.pop();
+          constraints.pop();
+          constraints.push(where("name", ">=", searchTerm));
+          constraints.push(where("name", "<=", searchTerm + "\uf8ff"));
+          constraints.push(orderBy("name"));
+          q = query(collection(this.db, PROCEDURES_COLLECTION), ...constraints);
+          querySnapshot = await getDocs(q);
         }
-
-        // Set last document for pagination
-        lastVisibleDoc =
-          querySnapshot.docs.length > 0
-            ? querySnapshot.docs[querySnapshot.docs.length - 1]
-            : null;
+        const procedures = querySnapshot.docs.map((doc) => ({ ...doc.data(), id: doc.id } as Procedure));
+        const lastVisibleDoc = querySnapshot.docs.length > 0 ? querySnapshot.docs[querySnapshot.docs.length - 1] : null;
+        return { procedures, lastDoc: lastVisibleDoc };
       }
-
-      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;
-  }
-
   /**
    * Creates a consultation procedure without requiring a product
    * This is a special method for consultation procedures that don't use products
@@ -1301,6 +1143,7 @@ export class ProcedureService extends BaseService {
     const newProcedure: Omit<Procedure, "createdAt" | "updatedAt"> = {
       id: procedureId,
       ...data,
+      nameLower: (data as any).nameLower || data.name.toLowerCase(),
       photos: processedPhotos,
       category,
       subcategory,
@@ -1340,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

package/src/types/procedure/index.ts

@@ -31,6 +31,8 @@ export interface Procedure {
   id: string;
   /** Name of the procedure */
   name: string;
+  /** Lowercase version of the name for case-insensitive search */
+  nameLower: string;
   /** Photos of the procedure */
   photos?: MediaResource[];
   /** Detailed description of the procedure */
@@ -90,6 +92,8 @@ export interface Procedure {
  */
 export interface CreateProcedureData {
   name: string;
+  /** Lowercase version of the name for case-insensitive search */
+  nameLower: string;
   description: string;
   family: ProcedureFamily;
   categoryId: string;
@@ -110,6 +114,8 @@ export interface CreateProcedureData {
  */
 export interface UpdateProcedureData {
   name?: string;
+  /** Lowercase version of the name for case-insensitive search */
+  nameLower?: string;
   description?: string;
   price?: number;
   currency?: Currency;

package/src/validations/procedure.schema.ts

@@ -12,6 +12,7 @@ import { mediaResourceSchema } from "./media.schema";
  */
 export const createProcedureSchema = z.object({
   name: z.string().min(1).max(200),
+  nameLower: z.string().min(1).max(200),
   description: z.string().min(1).max(2000),
   family: z.nativeEnum(ProcedureFamily),
   categoryId: z.string().min(1),
@@ -32,6 +33,7 @@ export const createProcedureSchema = z.object({
  */
 export const updateProcedureSchema = z.object({
   name: z.string().min(3).max(100).optional(),
+  nameLower: z.string().min(1).max(200).optional(),
   description: z.string().min(3).max(1000).optional(),
   price: z.number().min(0).optional(),
   currency: z.nativeEnum(Currency).optional(),
@@ -52,6 +54,7 @@ export const updateProcedureSchema = z.object({
  */
 export const procedureSchema = createProcedureSchema.extend({
   id: z.string().min(1),
+  nameLower: z.string().min(1).max(200),
   category: z.any(), // We'll validate the full category object separately
   subcategory: z.any(), // We'll validate the full subcategory object separately
   technology: z.any(), // We'll validate the full technology object separately