@blackcode_sa/metaestetics-api 1.12.64 → 1.12.66

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

@@ -1,11 +1,11 @@
-/**
- * Index file for clinic service utilities
- * Exports all utility functions from the other files
- */
-
-export * from "./clinic.utils";
-export * from "./clinic-group.utils";
-export * from "./admin.utils";
-export * from "./review.utils";
-export * from "./tag.utils";
-export * from "./search.utils";
+/**
+ * Index file for clinic service utilities
+ * Exports all utility functions from the other files
+ */
+
+export * from "./clinic.utils";
+export * from "./clinic-group.utils";
+export * from "./admin.utils";
+export * from "./review.utils";
+export * from "./tag.utils";
+export * from "./search.utils";

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

@@ -1,188 +1,188 @@
-import {
-  getStorage,
-  ref,
-  uploadBytes,
-  getDownloadURL,
-  deleteObject,
-} from "firebase/storage";
-import { FirebaseApp } from "firebase/app";
-
-/**
- * Uploads a photo to Firebase Storage
- * @param photo - The photo data URL or URL
- * @param entityType - The type of entity (clinic-groups, clinics, etc.)
- * @param entityId - The ID of the entity
- * @param photoType - The type of photo (logo, featured, etc.)
- * @param app - Firebase app instance
- * @param fileName - Optional custom file name
- * @returns The URL of the uploaded photo or null if upload failed
- */
-export async function uploadPhoto(
-  photo: string | null,
-  entityType: string,
-  entityId: string,
-  photoType: string,
-  app: FirebaseApp,
-  fileName?: string
-): Promise<string | null> {
-  // If photo is null or not a data URL, return it as is
-  if (!photo || typeof photo !== "string" || !photo.startsWith("data:")) {
-    return photo;
-  }
-
-  try {
-    console.log(
-      `[PHOTO_UTILS] Uploading ${photoType} for ${entityType}/${entityId}`
-    );
-
-    // Get Firebase Storage instance
-    const storage = getStorage(app);
-
-    // Create a reference to the storage location
-    const storageFileName = fileName || `${photoType}-${Date.now()}`;
-    const storageRef = ref(
-      storage,
-      `${entityType}/${entityId}/${storageFileName}`
-    );
-
-    // Extract base64 data from data URL
-    const base64Data = photo.split(",")[1];
-    const contentType = photo.split(";")[0].split(":")[1];
-
-    // Convert base64 to Blob
-    const byteCharacters = atob(base64Data);
-    const byteArrays = [];
-    for (let i = 0; i < byteCharacters.length; i++) {
-      byteArrays.push(byteCharacters.charCodeAt(i));
-    }
-    const blob = new Blob([new Uint8Array(byteArrays)], { type: contentType });
-
-    // Upload the file
-    await uploadBytes(storageRef, blob, { contentType });
-
-    // Get the download URL
-    const downloadUrl = await getDownloadURL(storageRef);
-
-    console.log(`[PHOTO_UTILS] ${photoType} uploaded successfully`, {
-      downloadUrl,
-    });
-    return downloadUrl;
-  } catch (error) {
-    console.error(`[PHOTO_UTILS] Error uploading ${photoType}:`, error);
-    return null;
-  }
-}
-
-/**
- * Deletes a photo from Firebase Storage
- * @param photoUrl - The URL of the photo to delete
- * @param app - Firebase app instance
- * @returns Whether the deletion was successful
- */
-export async function deletePhoto(
-  photoUrl: string,
-  app: FirebaseApp
-): Promise<boolean> {
-  if (!photoUrl || !photoUrl.includes("firebasestorage.googleapis.com")) {
-    return false;
-  }
-
-  try {
-    console.log(`[PHOTO_UTILS] Deleting photo`, { photoUrl });
-
-    // Get Firebase Storage instance
-    const storage = getStorage(app);
-
-    // Extract the storage path from the URL
-    const storageRef = ref(storage, photoUrl);
-
-    // Delete the file
-    await deleteObject(storageRef);
-
-    console.log(`[PHOTO_UTILS] Photo deleted successfully`);
-    return true;
-  } catch (error) {
-    console.error(`[PHOTO_UTILS] Error deleting photo:`, error);
-    return false;
-  }
-}
-
-/**
- * Uploads multiple photos to Firebase Storage
- * @param photos - Array of photo data URLs or URLs
- * @param entityType - The type of entity (clinic-groups, clinics, etc.)
- * @param entityId - The ID of the entity
- * @param photoType - The type of photos (featured, gallery, etc.)
- * @param app - Firebase app instance
- * @returns Array of URLs of the uploaded photos
- */
-export async function uploadMultiplePhotos(
-  photos: string[],
-  entityType: string,
-  entityId: string,
-  photoType: string,
-  app: FirebaseApp
-): Promise<string[]> {
-  if (!photos || !Array.isArray(photos) || photos.length === 0) {
-    return [];
-  }
-
-  const uploadPromises = photos.map((photo, index) =>
-    uploadPhoto(photo, entityType, entityId, `${photoType}-${index}`, app)
-  );
-
-  try {
-    const results = await Promise.all(uploadPromises);
-    return results.filter((url): url is string => url !== null);
-  } catch (error) {
-    console.error(`[PHOTO_UTILS] Error uploading multiple photos:`, error);
-    return photos.filter((photo) => !photo.startsWith("data:"));
-  }
-}
-
-/**
- * Processes photos in an entity object, uploading any data URLs
- * @param entity - The entity object containing photo fields
- * @param entityType - The type of entity (clinic-groups, clinics, etc.)
- * @param entityId - The ID of the entity
- * @param photoFields - Array of field names that contain photos
- * @param app - Firebase app instance
- * @returns The entity with updated photo URLs
- */
-export async function processEntityPhotos<T extends Record<string, any>>(
-  entity: T,
-  entityType: string,
-  entityId: string,
-  photoFields: { field: keyof T; type: string }[],
-  app: FirebaseApp
-): Promise<T> {
-  const updatedEntity = { ...entity };
-
-  for (const { field, type } of photoFields) {
-    const value = entity[field];
-
-    if (!value) continue;
-
-    if (Array.isArray(value)) {
-      // Handle array of photos
-      updatedEntity[field] = (await uploadMultiplePhotos(
-        value,
-        entityType,
-        entityId,
-        type,
-        app
-      )) as any;
-    } else if (typeof value === "string") {
-      // Handle single photo
-      updatedEntity[field] = (await uploadPhoto(
-        value,
-        entityType,
-        entityId,
-        type,
-        app
-      )) as any;
-    }
-  }
-
-  return updatedEntity;
-}
+import {
+  getStorage,
+  ref,
+  uploadBytes,
+  getDownloadURL,
+  deleteObject,
+} from "firebase/storage";
+import { FirebaseApp } from "firebase/app";
+
+/**
+ * Uploads a photo to Firebase Storage
+ * @param photo - The photo data URL or URL
+ * @param entityType - The type of entity (clinic-groups, clinics, etc.)
+ * @param entityId - The ID of the entity
+ * @param photoType - The type of photo (logo, featured, etc.)
+ * @param app - Firebase app instance
+ * @param fileName - Optional custom file name
+ * @returns The URL of the uploaded photo or null if upload failed
+ */
+export async function uploadPhoto(
+  photo: string | null,
+  entityType: string,
+  entityId: string,
+  photoType: string,
+  app: FirebaseApp,
+  fileName?: string
+): Promise<string | null> {
+  // If photo is null or not a data URL, return it as is
+  if (!photo || typeof photo !== "string" || !photo.startsWith("data:")) {
+    return photo;
+  }
+
+  try {
+    console.log(
+      `[PHOTO_UTILS] Uploading ${photoType} for ${entityType}/${entityId}`
+    );
+
+    // Get Firebase Storage instance
+    const storage = getStorage(app);
+
+    // Create a reference to the storage location
+    const storageFileName = fileName || `${photoType}-${Date.now()}`;
+    const storageRef = ref(
+      storage,
+      `${entityType}/${entityId}/${storageFileName}`
+    );
+
+    // Extract base64 data from data URL
+    const base64Data = photo.split(",")[1];
+    const contentType = photo.split(";")[0].split(":")[1];
+
+    // Convert base64 to Blob
+    const byteCharacters = atob(base64Data);
+    const byteArrays = [];
+    for (let i = 0; i < byteCharacters.length; i++) {
+      byteArrays.push(byteCharacters.charCodeAt(i));
+    }
+    const blob = new Blob([new Uint8Array(byteArrays)], { type: contentType });
+
+    // Upload the file
+    await uploadBytes(storageRef, blob, { contentType });
+
+    // Get the download URL
+    const downloadUrl = await getDownloadURL(storageRef);
+
+    console.log(`[PHOTO_UTILS] ${photoType} uploaded successfully`, {
+      downloadUrl,
+    });
+    return downloadUrl;
+  } catch (error) {
+    console.error(`[PHOTO_UTILS] Error uploading ${photoType}:`, error);
+    return null;
+  }
+}
+
+/**
+ * Deletes a photo from Firebase Storage
+ * @param photoUrl - The URL of the photo to delete
+ * @param app - Firebase app instance
+ * @returns Whether the deletion was successful
+ */
+export async function deletePhoto(
+  photoUrl: string,
+  app: FirebaseApp
+): Promise<boolean> {
+  if (!photoUrl || !photoUrl.includes("firebasestorage.googleapis.com")) {
+    return false;
+  }
+
+  try {
+    console.log(`[PHOTO_UTILS] Deleting photo`, { photoUrl });
+
+    // Get Firebase Storage instance
+    const storage = getStorage(app);
+
+    // Extract the storage path from the URL
+    const storageRef = ref(storage, photoUrl);
+
+    // Delete the file
+    await deleteObject(storageRef);
+
+    console.log(`[PHOTO_UTILS] Photo deleted successfully`);
+    return true;
+  } catch (error) {
+    console.error(`[PHOTO_UTILS] Error deleting photo:`, error);
+    return false;
+  }
+}
+
+/**
+ * Uploads multiple photos to Firebase Storage
+ * @param photos - Array of photo data URLs or URLs
+ * @param entityType - The type of entity (clinic-groups, clinics, etc.)
+ * @param entityId - The ID of the entity
+ * @param photoType - The type of photos (featured, gallery, etc.)
+ * @param app - Firebase app instance
+ * @returns Array of URLs of the uploaded photos
+ */
+export async function uploadMultiplePhotos(
+  photos: string[],
+  entityType: string,
+  entityId: string,
+  photoType: string,
+  app: FirebaseApp
+): Promise<string[]> {
+  if (!photos || !Array.isArray(photos) || photos.length === 0) {
+    return [];
+  }
+
+  const uploadPromises = photos.map((photo, index) =>
+    uploadPhoto(photo, entityType, entityId, `${photoType}-${index}`, app)
+  );
+
+  try {
+    const results = await Promise.all(uploadPromises);
+    return results.filter((url): url is string => url !== null);
+  } catch (error) {
+    console.error(`[PHOTO_UTILS] Error uploading multiple photos:`, error);
+    return photos.filter((photo) => !photo.startsWith("data:"));
+  }
+}
+
+/**
+ * Processes photos in an entity object, uploading any data URLs
+ * @param entity - The entity object containing photo fields
+ * @param entityType - The type of entity (clinic-groups, clinics, etc.)
+ * @param entityId - The ID of the entity
+ * @param photoFields - Array of field names that contain photos
+ * @param app - Firebase app instance
+ * @returns The entity with updated photo URLs
+ */
+export async function processEntityPhotos<T extends Record<string, any>>(
+  entity: T,
+  entityType: string,
+  entityId: string,
+  photoFields: { field: keyof T; type: string }[],
+  app: FirebaseApp
+): Promise<T> {
+  const updatedEntity = { ...entity };
+
+  for (const { field, type } of photoFields) {
+    const value = entity[field];
+
+    if (!value) continue;
+
+    if (Array.isArray(value)) {
+      // Handle array of photos
+      updatedEntity[field] = (await uploadMultiplePhotos(
+        value,
+        entityType,
+        entityId,
+        type,
+        app
+      )) as any;
+    } else if (typeof value === "string") {
+      // Handle single photo
+      updatedEntity[field] = (await uploadPhoto(
+        value,
+        entityType,
+        entityId,
+        type,
+        app
+      )) as any;
+    }
+  }
+
+  return updatedEntity;
+}

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

@@ -1,84 +1,84 @@
-import {
-  collection,
-  query,
-  where,
-  getDocs,
-  Firestore,
-  QueryConstraint,
-} from "firebase/firestore";
-import { Clinic, ClinicTag, CLINICS_COLLECTION } from "../../../types/clinic";
-import { geohashQueryBounds, distanceBetween } from "geofire-common";
-
-/**
- * Finds clinics within a specified radius
- * @param db - Firestore database instance
- * @param center - Center coordinates
- * @param radiusInKm - Radius in kilometers
- * @param filters - Optional filters for services and tags
- * @returns Array of clinics within the radius
- */
-export async function findClinicsInRadius(
-  db: Firestore,
-  center: { latitude: number; longitude: number },
-  radiusInKm: number,
-  filters?: {
-    services?: string[];
-    tags?: ClinicTag[];
-  }
-): Promise<Clinic[]> {
-  const bounds = geohashQueryBounds(
-    [center.latitude, center.longitude],
-    radiusInKm * 1000
-  );
-
-  const matchingDocs: Clinic[] = [];
-
-  for (const b of bounds) {
-    const constraints: QueryConstraint[] = [
-      where("location.geohash", ">=", b[0]),
-      where("location.geohash", "<=", b[1]),
-      where("isActive", "==", true),
-    ];
-
-    if (filters?.services) {
-      constraints.push(
-        where("services", "array-contains-any", filters.services)
-      );
-    }
-
-    if (filters?.tags && filters.tags.length > 0) {
-      constraints.push(where("tags", "array-contains-any", filters.tags));
-    }
-
-    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]
-      );
-
-      // Konvertujemo u kilometre
-      const distanceInKm = distance / 1000;
-
-      if (distanceInKm <= radiusInKm) {
-        matchingDocs.push(clinic);
-      }
-    }
-  }
-
-  // Sortiramo po udaljenosti
-  return matchingDocs.sort((a, b) => {
-    const distanceA = distanceBetween(
-      [center.latitude, center.longitude],
-      [a.location.latitude, a.location.longitude]
-    );
-    const distanceB = distanceBetween(
-      [center.latitude, center.longitude],
-      [b.location.latitude, b.location.longitude]
-    );
-    return distanceA - distanceB;
-  });
-}
+import {
+  collection,
+  query,
+  where,
+  getDocs,
+  Firestore,
+  QueryConstraint,
+} from "firebase/firestore";
+import { Clinic, ClinicTag, CLINICS_COLLECTION } from "../../../types/clinic";
+import { geohashQueryBounds, distanceBetween } from "geofire-common";
+
+/**
+ * Finds clinics within a specified radius
+ * @param db - Firestore database instance
+ * @param center - Center coordinates
+ * @param radiusInKm - Radius in kilometers
+ * @param filters - Optional filters for services and tags
+ * @returns Array of clinics within the radius
+ */
+export async function findClinicsInRadius(
+  db: Firestore,
+  center: { latitude: number; longitude: number },
+  radiusInKm: number,
+  filters?: {
+    services?: string[];
+    tags?: ClinicTag[];
+  }
+): Promise<Clinic[]> {
+  const bounds = geohashQueryBounds(
+    [center.latitude, center.longitude],
+    radiusInKm * 1000
+  );
+
+  const matchingDocs: Clinic[] = [];
+
+  for (const b of bounds) {
+    const constraints: QueryConstraint[] = [
+      where("location.geohash", ">=", b[0]),
+      where("location.geohash", "<=", b[1]),
+      where("isActive", "==", true),
+    ];
+
+    if (filters?.services) {
+      constraints.push(
+        where("services", "array-contains-any", filters.services)
+      );
+    }
+
+    if (filters?.tags && filters.tags.length > 0) {
+      constraints.push(where("tags", "array-contains-any", filters.tags));
+    }
+
+    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]
+      );
+
+      // Konvertujemo u kilometre
+      const distanceInKm = distance / 1000;
+
+      if (distanceInKm <= radiusInKm) {
+        matchingDocs.push(clinic);
+      }
+    }
+  }
+
+  // Sortiramo po udaljenosti
+  return matchingDocs.sort((a, b) => {
+    const distanceA = distanceBetween(
+      [center.latitude, center.longitude],
+      [a.location.latitude, a.location.longitude]
+    );
+    const distanceB = distanceBetween(
+      [center.latitude, center.longitude],
+      [b.location.latitude, b.location.longitude]
+    );
+    return distanceA - distanceB;
+  });
+}