@blackcode_sa/metaestetics-api 1.5.27 → 1.5.29

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

@@ -18,17 +18,19 @@ import {
   Clinic,
   CreateClinicData,
   CLINICS_COLLECTION,
-  ClinicReview,
   ClinicTag,
   ClinicGroup,
   ClinicBranchSetupData,
   ClinicLocation,
 } from "../../../types/clinic";
-import { geohashForLocation } from "geofire-common";
+import {
+  geohashForLocation,
+  distanceBetween,
+  geohashQueryBounds,
+} from "geofire-common";
 import {
   clinicSchema,
   createClinicSchema,
-  clinicReviewSchema,
 } from "../../../validations/clinic.schema";
 import { z } from "zod";
 import { FirebaseApp } from "firebase/app";
@@ -273,11 +275,18 @@ export async function createClinic(
     photosWithTags: processedPhotosWithTags,
     doctors: [],
     doctorsInfo: [],
-    services: [],
-    servicesInfo: [],
-    reviews: [],
-    reviewsInfo: [],
-    rating: { average: 0, count: 0 },
+    procedures: [],
+    proceduresInfo: [],
+    reviewInfo: {
+      totalReviews: 0,
+      averageRating: 0,
+      cleanliness: 0,
+      facilities: 0,
+      staffFriendliness: 0,
+      waitingTime: 0,
+      accessibility: 0,
+      recommendationPercentage: 0,
+    },
     admins: [creatorAdminId],
     createdAt: now,
     updatedAt: now,
@@ -768,3 +777,173 @@ export async function getActiveClinicsByAdmin(
     clinicGroupService
   );
 }
+
+/**
+ * Retrieves a clinic by its ID
+ *
+ * @param db - Firestore database instance
+ * @param clinicId - ID of the clinic to retrieve
+ * @returns The clinic if found, null otherwise
+ */
+export async function getClinicById(
+  db: Firestore,
+  clinicId: string
+): Promise<Clinic | null> {
+  try {
+    const clinicRef = doc(db, CLINICS_COLLECTION, clinicId);
+    const clinicSnapshot = await getDoc(clinicRef);
+
+    if (!clinicSnapshot.exists()) {
+      return null;
+    }
+
+    const clinicData = clinicSnapshot.data() as Clinic;
+    return {
+      ...clinicData,
+      id: clinicSnapshot.id,
+    };
+  } catch (error) {
+    console.error("[CLINIC_UTILS] Error getting clinic by ID:", error);
+    throw error;
+  }
+}
+
+/**
+ * Retrieves all clinics with optional pagination
+ *
+ * @param db - Firestore database instance
+ * @param pagination - Optional number of clinics per page (0 or undefined returns all)
+ * @param lastDoc - Optional last document for pagination (if continuing from a previous page)
+ * @returns Array of clinics and the last document for pagination
+ */
+export async function getAllClinics(
+  db: Firestore,
+  pagination?: number,
+  lastDoc?: any
+): Promise<{ clinics: Clinic[]; lastDoc: any }> {
+  try {
+    const clinicsCollection = collection(db, CLINICS_COLLECTION);
+    let clinicsQuery = query(clinicsCollection);
+
+    // If pagination is specified and greater than 0, limit the query
+    if (pagination && pagination > 0) {
+      const { limit, startAfter } = require("firebase/firestore");
+
+      if (lastDoc) {
+        clinicsQuery = query(
+          clinicsCollection,
+          startAfter(lastDoc),
+          limit(pagination)
+        );
+      } else {
+        clinicsQuery = query(clinicsCollection, limit(pagination));
+      }
+    }
+
+    const clinicsSnapshot = await getDocs(clinicsQuery);
+    const lastVisible = clinicsSnapshot.docs[clinicsSnapshot.docs.length - 1];
+
+    const clinics = clinicsSnapshot.docs.map((doc) => {
+      const data = doc.data() as Clinic;
+      return {
+        ...data,
+        id: doc.id,
+      };
+    });
+
+    return {
+      clinics,
+      lastDoc: lastVisible,
+    };
+  } catch (error) {
+    console.error("[CLINIC_UTILS] Error getting all clinics:", error);
+    throw error;
+  }
+}
+
+/**
+ * Retrieves all clinics within a specified range from a location with optional pagination
+ *
+ * @param db - Firestore database instance
+ * @param center - The center location coordinates {latitude, longitude}
+ * @param rangeInKm - The range in kilometers to search within
+ * @param pagination - Optional number of clinics per page (0 or undefined returns all)
+ * @param lastDoc - Optional last document for pagination (if continuing from a previous page)
+ * @returns Array of clinics with distance information and the last document for pagination
+ */
+export async function getAllClinicsInRange(
+  db: Firestore,
+  center: { latitude: number; longitude: number },
+  rangeInKm: number,
+  pagination?: number,
+  lastDoc?: any
+): Promise<{ clinics: (Clinic & { distance: number })[]; lastDoc: any }> {
+  const bounds = geohashQueryBounds(
+    [center.latitude, center.longitude],
+    rangeInKm * 1000
+  );
+
+  const matchingClinics: (Clinic & { distance: number })[] = [];
+  let lastDocSnapshot = null;
+
+  for (const b of bounds) {
+    const constraints: QueryConstraint[] = [
+      where("location.geohash", ">=", b[0]),
+      where("location.geohash", "<=", b[1]),
+      where("isActive", "==", true),
+    ];
+
+    const q = query(collection(db, CLINICS_COLLECTION), ...constraints);
+    const querySnapshot = await getDocs(q);
+
+    for (const doc of querySnapshot.docs) {
+      const clinic = doc.data() as Clinic;
+      const distance = distanceBetween(
+        [center.latitude, center.longitude],
+        [clinic.location.latitude, clinic.location.longitude]
+      );
+
+      // Convert to kilometers
+      const distanceInKm = distance / 1000;
+
+      if (distanceInKm <= rangeInKm) {
+        matchingClinics.push({
+          ...clinic,
+          distance: distanceInKm,
+        });
+      }
+    }
+  }
+
+  // Sort by distance
+  matchingClinics.sort((a, b) => a.distance - b.distance);
+
+  if (pagination && pagination > 0) {
+    // Paginate results
+    let result = matchingClinics;
+    if (lastDoc && matchingClinics.length > 0) {
+      const lastIndex = matchingClinics.findIndex(
+        (clinic) => clinic.id === lastDoc.id
+      );
+      if (lastIndex !== -1) {
+        result = matchingClinics.slice(lastIndex + 1);
+      }
+    }
+
+    const paginatedClinics = result.slice(0, pagination);
+    const newLastDoc =
+      paginatedClinics.length > 0
+        ? paginatedClinics[paginatedClinics.length - 1]
+        : null;
+
+    return {
+      clinics: paginatedClinics,
+      lastDoc: newLastDoc,
+    };
+  }
+
+  return {
+    clinics: matchingClinics,
+    lastDoc: null,
+  };
+}

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

@@ -0,0 +1,23 @@
+import { Firestore } from "firebase/firestore";
+import { Clinic, ClinicTag } from "../../../types/clinic";
+
+export function getClinicsByFilters(
+  db: Firestore,
+  filters: {
+    center?: { latitude: number; longitude: number };
+    radiusInKm?: number;
+    tags?: ClinicTag[];
+    procedureFamily?: string;
+    procedureCategory?: string;
+    procedureSubcategory?: string;
+    procedureTechnology?: string;
+    minRating?: number;
+    maxRating?: number;
+    pagination?: number;
+    lastDoc?: any;
+    isActive?: boolean;
+  }
+): Promise<{
+  clinics: (Clinic & { distance?: number })[];
+  lastDoc: any;
+}>;

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

@@ -0,0 +1,264 @@
+import {
+  collection,
+  query,
+  where,
+  getDocs,
+  Firestore,
+  QueryConstraint,
+  startAfter,
+  limit,
+  documentId,
+  orderBy,
+} from "firebase/firestore";
+import { Clinic, ClinicTag, CLINICS_COLLECTION } from "../../../types/clinic";
+import { geohashQueryBounds, distanceBetween } from "geofire-common";
+
+/**
+ * Get clinics based on multiple filtering criteria
+ *
+ * @param db - Firestore database instance
+ * @param filters - Various filters to apply
+ * @returns Filtered clinics and the last document for pagination
+ */
+export async function getClinicsByFilters(
+  db: Firestore,
+  filters: {
+    center?: { latitude: number; longitude: number };
+    radiusInKm?: number;
+    tags?: ClinicTag[];
+    procedureFamily?: string;
+    procedureCategory?: string;
+    procedureSubcategory?: string;
+    procedureTechnology?: string;
+    minRating?: number;
+    maxRating?: number;
+    pagination?: number;
+    lastDoc?: any;
+    isActive?: boolean;
+  }
+): Promise<{
+  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
+  const constraints: QueryConstraint[] = [];
+
+  // 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
+  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
+  if (filters.procedureTechnology) {
+    constraints.push(
+      where("servicesInfo.technology", "==", filters.procedureTechnology)
+    );
+  } else if (filters.procedureSubcategory) {
+    constraints.push(
+      where("servicesInfo.subCategory", "==", filters.procedureSubcategory)
+    );
+  } else if (filters.procedureCategory) {
+    constraints.push(
+      where("servicesInfo.category", "==", filters.procedureCategory)
+    );
+  } else if (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));
+  }
+
+  // Add ordering to make pagination consistent
+  constraints.push(orderBy(documentId()));
+
+  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;
+
+      clinicsResult = paginatedClinics;
+    } else {
+      clinicsResult = filteredClinics;
+    }
+  } 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);
+
+    console.log(
+      `[FILTER_UTILS] Found ${querySnapshot.docs.length} clinics with regular query`
+    );
+
+    // Convert docs to clinics
+    const clinics = querySnapshot.docs.map((doc) => {
+      return { ...doc.data(), id: doc.id } as Clinic;
+    });
+
+    // Apply filters that couldn't be applied in the query
+    let filteredClinics = clinics;
+
+    // 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,
+  };
+}