@blackcode_sa/metaestetics-api 1.4.17 → 1.5.0

package/src/services/calendar/utils/synced-calendar.utils.ts

@@ -0,0 +1,472 @@
+import {
+  Firestore,
+  collection,
+  doc,
+  getDoc,
+  getDocs,
+  setDoc,
+  updateDoc,
+  deleteDoc,
+  query,
+  where,
+  orderBy,
+  Timestamp,
+  serverTimestamp,
+} from "firebase/firestore";
+import {
+  SyncedCalendar,
+  SyncedCalendarProvider,
+  CreateSyncedCalendarData,
+  UpdateSyncedCalendarData,
+  SYNCED_CALENDARS_COLLECTION,
+} from "../../../types/calendar/synced-calendar.types";
+import {
+  getPractitionerSyncedCalendarDocRef,
+  getPatientSyncedCalendarDocRef,
+  getClinicSyncedCalendarDocRef,
+} from "./docs.utils";
+
+/**
+ * Creates a synced calendar for a practitioner
+ * @param db - Firestore instance
+ * @param practitionerId - ID of the practitioner
+ * @param calendarData - Synced calendar data
+ * @param generateId - Function to generate a unique ID
+ * @returns Created synced calendar
+ */
+export async function createPractitionerSyncedCalendarUtil(
+  db: Firestore,
+  practitionerId: string,
+  calendarData: Omit<
+    CreateSyncedCalendarData,
+    "id" | "createdAt" | "updatedAt"
+  >,
+  generateId: () => string
+): Promise<SyncedCalendar> {
+  const calendarId = generateId();
+  const calendarRef = getPractitionerSyncedCalendarDocRef(
+    db,
+    practitionerId,
+    calendarId
+  );
+
+  const newCalendar: CreateSyncedCalendarData = {
+    id: calendarId,
+    ...calendarData,
+    createdAt: serverTimestamp(),
+    updatedAt: serverTimestamp(),
+  };
+
+  await setDoc(calendarRef, newCalendar);
+
+  // Convert server timestamp to Timestamp for return value
+  return {
+    ...newCalendar,
+    createdAt: Timestamp.now(),
+    updatedAt: Timestamp.now(),
+  } as SyncedCalendar;
+}
+
+/**
+ * Creates a synced calendar for a patient
+ * @param db - Firestore instance
+ * @param patientId - ID of the patient
+ * @param calendarData - Synced calendar data
+ * @param generateId - Function to generate a unique ID
+ * @returns Created synced calendar
+ */
+export async function createPatientSyncedCalendarUtil(
+  db: Firestore,
+  patientId: string,
+  calendarData: Omit<
+    CreateSyncedCalendarData,
+    "id" | "createdAt" | "updatedAt"
+  >,
+  generateId: () => string
+): Promise<SyncedCalendar> {
+  const calendarId = generateId();
+  const calendarRef = getPatientSyncedCalendarDocRef(db, patientId, calendarId);
+
+  const newCalendar: CreateSyncedCalendarData = {
+    id: calendarId,
+    ...calendarData,
+    createdAt: serverTimestamp(),
+    updatedAt: serverTimestamp(),
+  };
+
+  await setDoc(calendarRef, newCalendar);
+
+  // Convert server timestamp to Timestamp for return value
+  return {
+    ...newCalendar,
+    createdAt: Timestamp.now(),
+    updatedAt: Timestamp.now(),
+  } as SyncedCalendar;
+}
+
+/**
+ * Creates a synced calendar for a clinic
+ * @param db - Firestore instance
+ * @param clinicId - ID of the clinic
+ * @param calendarData - Synced calendar data
+ * @param generateId - Function to generate a unique ID
+ * @returns Created synced calendar
+ */
+export async function createClinicSyncedCalendarUtil(
+  db: Firestore,
+  clinicId: string,
+  calendarData: Omit<
+    CreateSyncedCalendarData,
+    "id" | "createdAt" | "updatedAt"
+  >,
+  generateId: () => string
+): Promise<SyncedCalendar> {
+  const calendarId = generateId();
+  const calendarRef = getClinicSyncedCalendarDocRef(db, clinicId, calendarId);
+
+  const newCalendar: CreateSyncedCalendarData = {
+    id: calendarId,
+    ...calendarData,
+    createdAt: serverTimestamp(),
+    updatedAt: serverTimestamp(),
+  };
+
+  await setDoc(calendarRef, newCalendar);
+
+  // Convert server timestamp to Timestamp for return value
+  return {
+    ...newCalendar,
+    createdAt: Timestamp.now(),
+    updatedAt: Timestamp.now(),
+  } as SyncedCalendar;
+}
+
+/**
+ * Gets a synced calendar for a practitioner
+ * @param db - Firestore instance
+ * @param practitionerId - ID of the practitioner
+ * @param calendarId - ID of the synced calendar
+ * @returns Synced calendar or null if not found
+ */
+export async function getPractitionerSyncedCalendarUtil(
+  db: Firestore,
+  practitionerId: string,
+  calendarId: string
+): Promise<SyncedCalendar | null> {
+  const calendarRef = getPractitionerSyncedCalendarDocRef(
+    db,
+    practitionerId,
+    calendarId
+  );
+  const calendarDoc = await getDoc(calendarRef);
+
+  if (!calendarDoc.exists()) {
+    return null;
+  }
+
+  return calendarDoc.data() as SyncedCalendar;
+}
+
+/**
+ * Gets all synced calendars for a practitioner
+ * @param db - Firestore instance
+ * @param practitionerId - ID of the practitioner
+ * @returns Array of synced calendars
+ */
+export async function getPractitionerSyncedCalendarsUtil(
+  db: Firestore,
+  practitionerId: string
+): Promise<SyncedCalendar[]> {
+  const calendarsRef = collection(
+    db,
+    `practitioners/${practitionerId}/${SYNCED_CALENDARS_COLLECTION}`
+  );
+
+  const q = query(calendarsRef, orderBy("createdAt", "desc"));
+  const querySnapshot = await getDocs(q);
+
+  return querySnapshot.docs.map((doc) => doc.data() as SyncedCalendar);
+}
+
+/**
+ * Gets a synced calendar for a patient
+ * @param db - Firestore instance
+ * @param patientId - ID of the patient
+ * @param calendarId - ID of the synced calendar
+ * @returns Synced calendar or null if not found
+ */
+export async function getPatientSyncedCalendarUtil(
+  db: Firestore,
+  patientId: string,
+  calendarId: string
+): Promise<SyncedCalendar | null> {
+  const calendarRef = getPatientSyncedCalendarDocRef(db, patientId, calendarId);
+  const calendarDoc = await getDoc(calendarRef);
+
+  if (!calendarDoc.exists()) {
+    return null;
+  }
+
+  return calendarDoc.data() as SyncedCalendar;
+}
+
+/**
+ * Gets all synced calendars for a patient
+ * @param db - Firestore instance
+ * @param patientId - ID of the patient
+ * @returns Array of synced calendars
+ */
+export async function getPatientSyncedCalendarsUtil(
+  db: Firestore,
+  patientId: string
+): Promise<SyncedCalendar[]> {
+  const calendarsRef = collection(
+    db,
+    `patients/${patientId}/${SYNCED_CALENDARS_COLLECTION}`
+  );
+
+  const q = query(calendarsRef, orderBy("createdAt", "desc"));
+  const querySnapshot = await getDocs(q);
+
+  return querySnapshot.docs.map((doc) => doc.data() as SyncedCalendar);
+}
+
+/**
+ * Gets a synced calendar for a clinic
+ * @param db - Firestore instance
+ * @param clinicId - ID of the clinic
+ * @param calendarId - ID of the synced calendar
+ * @returns Synced calendar or null if not found
+ */
+export async function getClinicSyncedCalendarUtil(
+  db: Firestore,
+  clinicId: string,
+  calendarId: string
+): Promise<SyncedCalendar | null> {
+  const calendarRef = getClinicSyncedCalendarDocRef(db, clinicId, calendarId);
+  const calendarDoc = await getDoc(calendarRef);
+
+  if (!calendarDoc.exists()) {
+    return null;
+  }
+
+  return calendarDoc.data() as SyncedCalendar;
+}
+
+/**
+ * Gets all synced calendars for a clinic
+ * @param db - Firestore instance
+ * @param clinicId - ID of the clinic
+ * @returns Array of synced calendars
+ */
+export async function getClinicSyncedCalendarsUtil(
+  db: Firestore,
+  clinicId: string
+): Promise<SyncedCalendar[]> {
+  const calendarsRef = collection(
+    db,
+    `clinics/${clinicId}/${SYNCED_CALENDARS_COLLECTION}`
+  );
+
+  const q = query(calendarsRef, orderBy("createdAt", "desc"));
+  const querySnapshot = await getDocs(q);
+
+  return querySnapshot.docs.map((doc) => doc.data() as SyncedCalendar);
+}
+
+/**
+ * Updates a synced calendar for a practitioner
+ * @param db - Firestore instance
+ * @param practitionerId - ID of the practitioner
+ * @param calendarId - ID of the synced calendar
+ * @param updateData - Data to update
+ * @returns Updated synced calendar
+ */
+export async function updatePractitionerSyncedCalendarUtil(
+  db: Firestore,
+  practitionerId: string,
+  calendarId: string,
+  updateData: Omit<UpdateSyncedCalendarData, "updatedAt">
+): Promise<SyncedCalendar> {
+  const calendarRef = getPractitionerSyncedCalendarDocRef(
+    db,
+    practitionerId,
+    calendarId
+  );
+
+  const updates: UpdateSyncedCalendarData = {
+    ...updateData,
+    updatedAt: serverTimestamp(),
+  };
+
+  await updateDoc(calendarRef, updates as any);
+
+  // Get the updated document
+  const updatedDoc = await getDoc(calendarRef);
+
+  if (!updatedDoc.exists()) {
+    throw new Error("Synced calendar not found after update");
+  }
+
+  return updatedDoc.data() as SyncedCalendar;
+}
+
+/**
+ * Updates a synced calendar for a patient
+ * @param db - Firestore instance
+ * @param patientId - ID of the patient
+ * @param calendarId - ID of the synced calendar
+ * @param updateData - Data to update
+ * @returns Updated synced calendar
+ */
+export async function updatePatientSyncedCalendarUtil(
+  db: Firestore,
+  patientId: string,
+  calendarId: string,
+  updateData: Omit<UpdateSyncedCalendarData, "updatedAt">
+): Promise<SyncedCalendar> {
+  const calendarRef = getPatientSyncedCalendarDocRef(db, patientId, calendarId);
+
+  const updates: UpdateSyncedCalendarData = {
+    ...updateData,
+    updatedAt: serverTimestamp(),
+  };
+
+  await updateDoc(calendarRef, updates as any);
+
+  // Get the updated document
+  const updatedDoc = await getDoc(calendarRef);
+
+  if (!updatedDoc.exists()) {
+    throw new Error("Synced calendar not found after update");
+  }
+
+  return updatedDoc.data() as SyncedCalendar;
+}
+
+/**
+ * Updates a synced calendar for a clinic
+ * @param db - Firestore instance
+ * @param clinicId - ID of the clinic
+ * @param calendarId - ID of the synced calendar
+ * @param updateData - Data to update
+ * @returns Updated synced calendar
+ */
+export async function updateClinicSyncedCalendarUtil(
+  db: Firestore,
+  clinicId: string,
+  calendarId: string,
+  updateData: Omit<UpdateSyncedCalendarData, "updatedAt">
+): Promise<SyncedCalendar> {
+  const calendarRef = getClinicSyncedCalendarDocRef(db, clinicId, calendarId);
+
+  const updates: UpdateSyncedCalendarData = {
+    ...updateData,
+    updatedAt: serverTimestamp(),
+  };
+
+  await updateDoc(calendarRef, updates as any);
+
+  // Get the updated document
+  const updatedDoc = await getDoc(calendarRef);
+
+  if (!updatedDoc.exists()) {
+    throw new Error("Synced calendar not found after update");
+  }
+
+  return updatedDoc.data() as SyncedCalendar;
+}
+
+/**
+ * Deletes a synced calendar for a practitioner
+ * @param db - Firestore instance
+ * @param practitionerId - ID of the practitioner
+ * @param calendarId - ID of the synced calendar
+ */
+export async function deletePractitionerSyncedCalendarUtil(
+  db: Firestore,
+  practitionerId: string,
+  calendarId: string
+): Promise<void> {
+  const calendarRef = getPractitionerSyncedCalendarDocRef(
+    db,
+    practitionerId,
+    calendarId
+  );
+  await deleteDoc(calendarRef);
+}
+
+/**
+ * Deletes a synced calendar for a patient
+ * @param db - Firestore instance
+ * @param patientId - ID of the patient
+ * @param calendarId - ID of the synced calendar
+ */
+export async function deletePatientSyncedCalendarUtil(
+  db: Firestore,
+  patientId: string,
+  calendarId: string
+): Promise<void> {
+  const calendarRef = getPatientSyncedCalendarDocRef(db, patientId, calendarId);
+  await deleteDoc(calendarRef);
+}
+
+/**
+ * Deletes a synced calendar for a clinic
+ * @param db - Firestore instance
+ * @param clinicId - ID of the clinic
+ * @param calendarId - ID of the synced calendar
+ */
+export async function deleteClinicSyncedCalendarUtil(
+  db: Firestore,
+  clinicId: string,
+  calendarId: string
+): Promise<void> {
+  const calendarRef = getClinicSyncedCalendarDocRef(db, clinicId, calendarId);
+  await deleteDoc(calendarRef);
+}
+
+/**
+ * Updates the last synced timestamp for a synced calendar
+ * @param db - Firestore instance
+ * @param entityType - Type of entity (practitioner, patient, clinic)
+ * @param entityId - ID of the entity
+ * @param calendarId - ID of the synced calendar
+ * @returns Updated synced calendar
+ */
+export async function updateLastSyncedTimestampUtil(
+  db: Firestore,
+  entityType: "practitioner" | "patient" | "clinic",
+  entityId: string,
+  calendarId: string
+): Promise<SyncedCalendar> {
+  const updateData: Omit<UpdateSyncedCalendarData, "updatedAt"> = {
+    lastSyncedAt: Timestamp.now(),
+  };
+
+  switch (entityType) {
+    case "practitioner":
+      return updatePractitionerSyncedCalendarUtil(
+        db,
+        entityId,
+        calendarId,
+        updateData
+      );
+    case "patient":
+      return updatePatientSyncedCalendarUtil(
+        db,
+        entityId,
+        calendarId,
+        updateData
+      );
+    case "clinic":
+      return updateClinicSyncedCalendarUtil(
+        db,
+        entityId,
+        calendarId,
+        updateData
+      );
+    default:
+      throw new Error(`Invalid entity type: ${entityType}`);
+  }
+}

package/src/services/clinic/clinic.service.ts

@@ -267,7 +267,7 @@ export class ClinicService extends BaseService {
       contactInfo: setupData.contactInfo,
       workingHours: setupData.workingHours,
       tags: setupData.tags,
-      photos: setupData.photos || [],
+      coverPhoto: setupData.coverPhoto || null,
       photosWithTags: setupData.photosWithTags || [],
       doctors: [],
       services: [],
@@ -281,7 +281,7 @@ export class ClinicService extends BaseService {
     console.log("[CLINIC_SERVICE] Creating clinic branch with data", {
       name: createClinicData.name,
       hasLogo: !!createClinicData.logo,
-      photosCount: createClinicData.photos.length,
+      hasCoverPhoto: !!createClinicData.coverPhoto,
       featuredPhotosCount: createClinicData.featuredPhotos?.length || 0,
       photosWithTagsCount: createClinicData.photosWithTags?.length || 0,
     });

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

@@ -153,27 +153,27 @@ export async function createClinic(
     }
   }
 
-  // Handle regular photos upload
-  let processedPhotos: string[] = [];
-  if (validatedData.photos && validatedData.photos.length > 0) {
-    console.log("[CLINIC] Processing regular photos");
+  // Handle cover photo upload
+  let processedCoverPhoto: string | null = null;
+  if (validatedData.coverPhoto) {
+    console.log("[CLINIC] Processing cover photo");
     try {
-      processedPhotos = await uploadMultiplePhotos(
-        validatedData.photos,
+      processedCoverPhoto = await uploadPhoto(
+        validatedData.coverPhoto,
         "clinics",
         clinicId,
-        "photo",
+        "cover",
         app
       );
-      console.log("[CLINIC] Regular photos processed", {
-        count: processedPhotos.length,
+      console.log("[CLINIC] Cover photo processed", {
+        coverPhoto: processedCoverPhoto,
       });
-    } catch (photosError) {
-      console.error("[CLINIC] Error processing regular photos:", photosError);
-      // Continue with clinic creation even if photos upload fails
-      processedPhotos = validatedData.photos.filter(
-        (photo) => !photo.startsWith("data:")
-      );
+    } catch (coverPhotoError) {
+      console.error("[CLINIC] Error processing cover photo:", coverPhotoError);
+      // Continue with clinic creation even if cover photo upload fails
+      processedCoverPhoto = validatedData.coverPhoto.startsWith("data:")
+        ? null
+        : validatedData.coverPhoto;
     }
   }
 
@@ -269,7 +269,7 @@ export async function createClinic(
     logo: logoUrl || "",
     tags: validatedData.tags || [],
     featuredPhotos: processedFeaturedPhotos || [],
-    photos: processedPhotos || [],
+    coverPhoto: processedCoverPhoto,
     photosWithTags: processedPhotosWithTags,
     doctors: [],
     doctorsInfo: [],
@@ -443,9 +443,8 @@ export async function updateClinic(
     }
 
     // Check if admin is either:
-    // 1. The owner of the clinic group, OR
-    // 2. Has this clinic in their managed clinics list, OR
-    // 3. Is listed in the clinic's admins array
+    // 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) &&
@@ -500,42 +499,42 @@ export async function updateClinic(
     }
   }
 
-  // Handle regular photos update if provided
-  if (data.photos && data.photos.length > 0) {
-    console.log("[CLINIC] Processing regular photos update");
+  // Handle cover photo update if provided
+  if (data.coverPhoto) {
+    console.log("[CLINIC] Processing cover photo update");
     try {
-      // Filter out only data URLs that need to be uploaded
-      const dataUrlPhotos = data.photos.filter(
-        (photo) => typeof photo === "string" && photo.startsWith("data:")
-      );
-      const existingPhotos = data.photos.filter(
-        (photo) => typeof photo === "string" && !photo.startsWith("data:")
-      );
-
-      if (dataUrlPhotos.length > 0) {
-        const uploadedPhotos = await uploadMultiplePhotos(
-          dataUrlPhotos,
+      // Check if it's a data URL that needs to be uploaded
+      if (
+        typeof data.coverPhoto === "string" &&
+        data.coverPhoto.startsWith("data:")
+      ) {
+        const uploadedPhoto = await uploadPhoto(
+          data.coverPhoto,
           "clinics",
           clinicId,
-          "photo",
+          "cover",
           app
         );
-        console.log("[CLINIC] Regular photos update processed", {
-          count: uploadedPhotos.length,
-        });
-
-        // Combine existing photos with newly uploaded ones
-        updatedData.photos = [...existingPhotos, ...uploadedPhotos];
+        if (uploadedPhoto) {
+          updatedData.coverPhoto = uploadedPhoto;
+        }
+      } else {
+        // Keep existing photo URL
+        updatedData.coverPhoto = data.coverPhoto;
       }
-    } catch (photosError) {
+      console.log("[CLINIC] Cover photo update processed");
+    } catch (photoError) {
       console.error(
-        "[CLINIC] Error processing regular photos update:",
-        photosError
-      );
-      // Continue with update even if photos upload fails
-      updatedData.photos = data.photos.filter(
-        (photo) => typeof photo === "string" && !photo.startsWith("data:")
+        "[CLINIC] Error processing cover photo update:",
+        photoError
       );
+      // Keep existing photo if upload fails
+      if (
+        typeof data.coverPhoto === "string" &&
+        !data.coverPhoto.startsWith("data:")
+      ) {
+        updatedData.coverPhoto = data.coverPhoto;
+      }
     }
   }
 
@@ -565,6 +564,9 @@ export async function updateClinic(
 
         // Combine existing photos with newly uploaded ones
         updatedData.featuredPhotos = [...existingPhotos, ...uploadedPhotos];
+      } else {
+        // If no new photos to upload, just use the existing ones
+        updatedData.featuredPhotos = existingPhotos;
       }
     } catch (featuredError) {
       console.error(

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

@@ -92,6 +92,7 @@ export class PractitionerService extends BaseService {
         basicInfo: validatedData.basicInfo,
         certification: validatedData.certification,
         clinics: validatedData.clinics || [],
+        clinicWorkingHours: validatedData.clinicWorkingHours || [],
         isActive: validatedData.isActive,
         isVerified: validatedData.isVerified,
         createdAt: serverTimestamp(),