@blackcode_sa/metaestetics-api 1.4.8 → 1.4.9

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

@@ -0,0 +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;
+}

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

@@ -4,16 +4,20 @@ import {
   setDoc,
   Timestamp,
   Firestore,
+  getDoc,
+  addDoc,
 } from "firebase/firestore";
 import { Clinic, ClinicReview } from "../../../types/clinic";
 import { clinicReviewSchema } from "../../../validations/clinic.schema";
 import { getClinic, updateClinic } from "./clinic.utils";
+import { FirebaseApp } from "firebase/app";
 
 /**
  * Adds a review to a clinic
  * @param db - Firestore database instance
- * @param clinicId - ID of the clinic to review
+ * @param clinicId - ID of the clinic to add the review to
  * @param review - Review data
+ * @param app - Firebase app instance
  * @returns The created review
  */
 export async function addReview(
@@ -22,20 +26,25 @@ export async function addReview(
   review: Omit<
     ClinicReview,
     "id" | "clinicId" | "createdAt" | "updatedAt" | "isVerified"
-  >
+  >,
+  app: FirebaseApp
 ): Promise<ClinicReview> {
-  const clinic = await getClinic(db, clinicId);
-  if (!clinic) {
+  // Proveravamo da li klinika postoji
+  const clinicRef = doc(db, "clinics", clinicId);
+  const clinicSnap = await getDoc(clinicRef);
+
+  if (!clinicSnap.exists()) {
     throw new Error("Clinic not found");
   }
 
+  const clinic = clinicSnap.data();
+
+  // Kreiramo recenziju
   const now = Timestamp.now();
   const reviewData: ClinicReview = {
+    ...review,
     id: doc(collection(db, "clinic_reviews")).id,
     clinicId,
-    patientId: review.patientId,
-    rating: review.rating,
-    comment: review.comment,
     createdAt: now,
     updatedAt: now,
     isVerified: false,
@@ -45,7 +54,7 @@ export async function addReview(
   clinicReviewSchema.parse(reviewData);
 
   // Čuvamo recenziju
-  await setDoc(doc(db, "clinic_reviews", reviewData.id), reviewData);
+  await addDoc(collection(db, "clinic_reviews"), reviewData);
 
   // Ažuriramo prosečnu ocenu klinike
   const newRating = clinic.rating
@@ -68,18 +77,16 @@ export async function addReview(
         ...clinic.reviewsInfo,
         {
           id: reviewData.id,
-          rating: review.rating,
-          text: review.comment,
-          patientId: review.patientId,
-          patientName: "Patient", // This should be fetched from patient service
-          patientPhoto: "", // This should be fetched from patient service
-          createdAt: now,
-          updatedAt: now,
+          patientId: reviewData.patientId,
+          rating: reviewData.rating,
+          comment: reviewData.comment,
+          createdAt: reviewData.createdAt,
         },
       ],
     },
-    clinic.admins[0], // Using the first admin for the update
-    { getClinicAdmin: async (id: string) => ({ isGroupOwner: true }) } // Mock admin service
+    "system", // System update, no admin ID needed
+    null, // No clinic admin service needed for system updates
+    app
   );
 
   return reviewData;

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

@@ -1,6 +1,7 @@
 import { Firestore } from "firebase/firestore";
 import { Clinic, ClinicTag } from "../../../types/clinic";
 import { getClinic, updateClinic } from "./clinic.utils";
+import { FirebaseApp } from "firebase/app";
 
 /**
  * Adds tags to a clinic
@@ -9,6 +10,7 @@ import { getClinic, updateClinic } from "./clinic.utils";
  * @param adminId - ID of the admin making the change
  * @param newTags - Tags to add
  * @param clinicAdminService - Service for clinic admin operations
+ * @param app - Firebase app instance
  * @returns The updated clinic
  */
 export async function addTags(
@@ -18,7 +20,8 @@ export async function addTags(
   newTags: {
     tags?: ClinicTag[];
   },
-  clinicAdminService: any
+  clinicAdminService: any,
+  app: FirebaseApp
 ): Promise<Clinic> {
   const clinic = await getClinic(db, clinicId);
   if (!clinic) {
@@ -31,7 +34,16 @@ export async function addTags(
     throw new Error("Admin not found");
   }
 
-  if (!admin.isGroupOwner && !admin.clinicsManaged.includes(clinicId)) {
+  // Check if admin is either:
+  // 1. The owner of the clinic group that this clinic belongs to, OR
+  // 2. Has this clinic in their managed clinics list AND is listed in the clinic's admins array
+  const hasPermission =
+    (admin.isGroupOwner && admin.clinicGroupId === clinic.clinicGroupId) ||
+    (admin.clinicsManaged.includes(clinicId) &&
+      clinic.admins &&
+      clinic.admins.includes(adminId));
+
+  if (!hasPermission) {
     throw new Error("Admin does not have permission to update this clinic");
   }
 
@@ -45,7 +57,8 @@ export async function addTags(
       tags: updatedTags,
     },
     adminId,
-    clinicAdminService
+    clinicAdminService,
+    app
   );
 }
 
@@ -56,6 +69,7 @@ export async function addTags(
  * @param adminId - ID of the admin making the change
  * @param tagsToRemove - Tags to remove
  * @param clinicAdminService - Service for clinic admin operations
+ * @param app - Firebase app instance
  * @returns The updated clinic
  */
 export async function removeTags(
@@ -65,7 +79,8 @@ export async function removeTags(
   tagsToRemove: {
     tags?: ClinicTag[];
   },
-  clinicAdminService: any
+  clinicAdminService: any,
+  app: FirebaseApp
 ): Promise<Clinic> {
   const clinic = await getClinic(db, clinicId);
   if (!clinic) {
@@ -78,13 +93,22 @@ export async function removeTags(
     throw new Error("Admin not found");
   }
 
-  if (!admin.isGroupOwner && !admin.clinicsManaged.includes(clinicId)) {
+  // Check if admin is either:
+  // 1. The owner of the clinic group that this clinic belongs to, OR
+  // 2. Has this clinic in their managed clinics list AND is listed in the clinic's admins array
+  const hasPermission =
+    (admin.isGroupOwner && admin.clinicGroupId === clinic.clinicGroupId) ||
+    (admin.clinicsManaged.includes(clinicId) &&
+      clinic.admins &&
+      clinic.admins.includes(adminId));
+
+  if (!hasPermission) {
     throw new Error("Admin does not have permission to update this clinic");
   }
 
-  // Filter out tags that should be removed
+  // Remove specified tags
   const updatedTags = clinic.tags.filter(
-    (tag) => !tagsToRemove.tags?.includes(tag)
+    (tag) => !tagsToRemove.tags || !tagsToRemove.tags.includes(tag)
   );
 
   return updateClinic(
@@ -94,6 +118,7 @@ export async function removeTags(
       tags: updatedTags,
     },
     adminId,
-    clinicAdminService
+    clinicAdminService,
+    app
   );
 }

package/src/types/clinic/index.ts

@@ -107,7 +107,7 @@ export interface ClinicInfo {
 export interface ClinicAdmin {
   id: string;
   userRef: string;
-  clinicGroupId: string;
+  clinicGroupId: string; // Can be empty string initially for owners
   isGroupOwner: boolean;
   clinicsManaged: string[];
   clinicsManagedInfo: ClinicInfo[];
@@ -195,7 +195,7 @@ export interface ClinicGroup {
   admins: string[];
   adminsInfo: AdminInfo[];
   adminTokens: AdminToken[];
-  ownerId: string;
+  ownerId: string | null;
   createdAt: Timestamp;
   updatedAt: Timestamp;
   isActive: boolean;
@@ -216,7 +216,7 @@ export interface CreateClinicGroupData {
   hqLocation: ClinicLocation;
   contactInfo: ClinicContactInfo;
   contactPerson: ContactPerson;
-  ownerId: string;
+  ownerId: string | null;
   isActive: boolean;
   logo?: string | null;
   practiceType?: PracticeType;
@@ -355,12 +355,12 @@ export interface UpdateClinicData extends Partial<CreateClinicData> {
  */
 export interface CreateDefaultClinicGroupData {
   name: string;
-  ownerId: string;
+  ownerId: string | null;
   contactPerson: ContactPerson;
   contactInfo: ClinicContactInfo;
   hqLocation: ClinicLocation;
   isActive: boolean;
-  logo?: string;
+  logo?: string | null;
   practiceType?: PracticeType;
   languages?: Language[];
   subscriptionModel?: SubscriptionModel;

package/src/validations/clinic.schema.ts

@@ -200,7 +200,7 @@ export const clinicGroupSchema = z.object({
   admins: z.array(z.string()),
   adminsInfo: z.array(adminInfoSchema),
   adminTokens: z.array(adminTokenSchema),
-  ownerId: z.string(),
+  ownerId: z.string().nullable(),
   createdAt: z.instanceof(Date).or(z.instanceof(Timestamp)), // Timestamp
   updatedAt: z.instanceof(Date).or(z.instanceof(Timestamp)), // Timestamp
   isActive: z.boolean(),
@@ -290,7 +290,7 @@ export const createClinicGroupSchema = z.object({
   hqLocation: clinicLocationSchema,
   contactInfo: clinicContactInfoSchema,
   contactPerson: contactPersonSchema,
-  ownerId: z.string(),
+  ownerId: z.string().nullable(),
   isActive: z.boolean(),
   logo: z.string().optional().nullable(),
   practiceType: z.nativeEnum(PracticeType).optional(),
@@ -337,7 +337,7 @@ export const createClinicSchema = z.object({
  */
 export const createDefaultClinicGroupSchema = z.object({
   name: z.string(),
-  ownerId: z.string(),
+  ownerId: z.string().nullable(),
   contactPerson: contactPersonSchema,
   contactInfo: clinicContactInfoSchema,
   hqLocation: clinicLocationSchema,