@blackcode_sa/metaestetics-api 1.7.2 → 1.7.4

package/src/admin/calendar/calendar.admin.service.ts

@@ -42,47 +42,93 @@ export class CalendarAdminService {
     );
     const batch = this.db.batch();
     const serverTimestamp = admin.firestore.FieldValue.serverTimestamp();
+    let updatesAdded = 0;
 
-    // Note: The Appointment type in booking.admin.ts has `calendarEventId` (practitioner's event)
-    // but not direct IDs for patient and clinic calendar events.
-    // We need a robust way to find these if they aren't directly on the appointment object.
-    // For now, assuming we can query them or they are added to the Appointment type.
+    // Get the shared calendar event ID
+    const calendarEventId = appointment.calendarEventId;
 
-    // Let's assume the main appointment.calendarEventId is the practitioner's calendar event.
-    // The other calendar event IDs might need to be fetched or stored on the Appointment object.
-    // For this placeholder, we'll demonstrate updating one and note the others.
-
-    // TODO: Confirm how patient and clinic calendar event IDs are retrieved.
-    // Assuming they are named predictably or stored in appointment.additionalCalendarEventIds (example)
-
-    const practitionerCalendarEventPath = `${PRACTITIONERS_COLLECTION}/${appointment.practitionerId}/${CALENDAR_COLLECTION}/${appointment.calendarEventId}`;
-    // Example paths, these need to be accurate based on your data model:
-    // const patientCalendarEventPath = `${PATIENTS_COLLECTION}/${appointment.patientId}/${CALENDAR_COLLECTION}/${appointment.patientCalendarEventId}`;
-    // const clinicCalendarEventPath = `${CLINICS_COLLECTION}/${appointment.clinicBranchId}/${CALENDAR_COLLECTION}/${appointment.clinicCalendarEventId}`;
+    if (!calendarEventId) {
+      Logger.warn(
+        `[CalendarAdminService] Missing calendar event ID for appointment ${appointment.id}`
+      );
+      return;
+    }
 
-    if (appointment.calendarEventId) {
-      // Practitioner event
-      const practitionerEventRef = this.db.doc(practitionerCalendarEventPath);
+    // Update practitioner calendar event
+    if (appointment.practitionerId) {
+      const practitionerEventRef = this.db.doc(
+        `${PRACTITIONERS_COLLECTION}/${appointment.practitionerId}/${CALENDAR_COLLECTION}/${calendarEventId}`
+      );
       batch.update(practitionerEventRef, {
         status: newStatus,
         updatedAt: serverTimestamp,
       });
+      updatesAdded++;
+      Logger.debug(
+        `[CalendarAdminService] Added practitioner calendar event status update to batch`
+      );
+    } else {
+      Logger.warn(
+        `[CalendarAdminService] Missing practitioner ID for appointment ${appointment.id}`
+      );
+    }
+
+    // Update patient calendar event
+    if (appointment.patientId) {
+      const patientEventRef = this.db.doc(
+        `${PATIENTS_COLLECTION}/${appointment.patientId}/${CALENDAR_COLLECTION}/${calendarEventId}`
+      );
+      batch.update(patientEventRef, {
+        status: newStatus,
+        updatedAt: serverTimestamp,
+      });
+      updatesAdded++;
+      Logger.debug(
+        `[CalendarAdminService] Added patient calendar event status update to batch`
+      );
+    } else {
+      Logger.warn(
+        `[CalendarAdminService] Missing patient ID for appointment ${appointment.id}`
+      );
     }
-    // Add similar updates for patient and clinic calendar events once their refs are confirmed
-    // if (appointment.patientCalendarEventId) { ... }
-    // if (appointment.clinicCalendarEventId) { ... }
 
-    try {
-      await batch.commit();
-      Logger.info(
-        `[CalendarAdminService] Successfully updated calendar event statuses for appointment ${appointment.id}.`
+    // Update clinic calendar event
+    if (appointment.clinicBranchId) {
+      const clinicEventRef = this.db.doc(
+        `${CLINICS_COLLECTION}/${appointment.clinicBranchId}/${CALENDAR_COLLECTION}/${calendarEventId}`
+      );
+      batch.update(clinicEventRef, {
+        status: newStatus,
+        updatedAt: serverTimestamp,
+      });
+      updatesAdded++;
+      Logger.debug(
+        `[CalendarAdminService] Added clinic calendar event status update to batch`
+      );
+    } else {
+      Logger.warn(
+        `[CalendarAdminService] Missing clinic ID for appointment ${appointment.id}`
       );
-    } catch (error) {
-      Logger.error(
-        `[CalendarAdminService] Error updating calendar event statuses for appointment ${appointment.id}:`,
-        error
+    }
+
+    // Only commit if we have updates to make
+    if (updatesAdded > 0) {
+      try {
+        await batch.commit();
+        Logger.info(
+          `[CalendarAdminService] Successfully updated ${updatesAdded} calendar event statuses for appointment ${appointment.id}.`
+        );
+      } catch (error) {
+        Logger.error(
+          `[CalendarAdminService] Error updating calendar event statuses for appointment ${appointment.id}:`,
+          error
+        );
+        throw error; // Re-throw to allow caller to handle
+      }
+    } else {
+      Logger.warn(
+        `[CalendarAdminService] No calendar event status updates were made for appointment ${appointment.id}`
       );
-      // Decide on error handling: re-throw, or log and continue?
     }
   }
 
@@ -91,51 +137,113 @@ export class CalendarAdminService {
    * associated with a given appointment.
    *
    * @param appointment - The appointment object.
-   * @param newEventTime - The new CalendarEventTime object (using FirebaseClientTimestamp).
+   * @param newEventTime - The new CalendarEventTime object (using admin.firestore.Timestamp).
    * @returns {Promise<void>} A promise that resolves when all updates are attempted.
    */
   async updateAppointmentCalendarEventsTime(
     appointment: Appointment,
-    newEventTime: CalendarEventTime // Expecting { start: FirebaseClientTimestamp, end: FirebaseClientTimestamp }
+    newEventTime: {
+      start: admin.firestore.Timestamp;
+      end: admin.firestore.Timestamp;
+    }
   ): Promise<void> {
     Logger.info(
       `[CalendarAdminService] Updating calendar event times for appointment ${appointment.id}`
     );
     const batch = this.db.batch();
     const serverTimestamp = admin.firestore.FieldValue.serverTimestamp();
+    let updatesAdded = 0;
+
+    // Get the shared calendar event ID
+    const calendarEventId = appointment.calendarEventId;
 
-    // Convert client timestamps to admin timestamps since we're in server mode
+    if (!calendarEventId) {
+      Logger.warn(
+        `[CalendarAdminService] Missing calendar event ID for appointment ${appointment.id}`
+      );
+      return;
+    }
+
+    // Use the timestamps directly since they are already admin.firestore.Timestamp
     const firestoreCompatibleEventTime = {
-      start:
-        TimestampUtils.clientToAdmin(newEventTime.start) ||
-        admin.firestore.Timestamp.now(),
-      end:
-        TimestampUtils.clientToAdmin(newEventTime.end) ||
-        admin.firestore.Timestamp.now(),
+      start: newEventTime.start,
+      end: newEventTime.end,
     };
 
-    // TODO: Confirm paths as in updateAppointmentCalendarEventsStatus
-    if (appointment.calendarEventId) {
-      // Practitioner event
+    // Update practitioner calendar event
+    if (appointment.practitionerId) {
       const practitionerEventRef = this.db.doc(
-        `${PRACTITIONERS_COLLECTION}/${appointment.practitionerId}/${CALENDAR_COLLECTION}/${appointment.calendarEventId}`
+        `${PRACTITIONERS_COLLECTION}/${appointment.practitionerId}/${CALENDAR_COLLECTION}/${calendarEventId}`
       );
       batch.update(practitionerEventRef, {
         eventTime: firestoreCompatibleEventTime,
         updatedAt: serverTimestamp,
       });
+      updatesAdded++;
+      Logger.debug(
+        `[CalendarAdminService] Added practitioner calendar event time update to batch`
+      );
+    } else {
+      Logger.warn(
+        `[CalendarAdminService] Missing practitioner ID for appointment ${appointment.id}`
+      );
+    }
+
+    // Update patient calendar event
+    if (appointment.patientId) {
+      const patientEventRef = this.db.doc(
+        `${PATIENTS_COLLECTION}/${appointment.patientId}/${CALENDAR_COLLECTION}/${calendarEventId}`
+      );
+      batch.update(patientEventRef, {
+        eventTime: firestoreCompatibleEventTime,
+        updatedAt: serverTimestamp,
+      });
+      updatesAdded++;
+      Logger.debug(
+        `[CalendarAdminService] Added patient calendar event time update to batch`
+      );
+    } else {
+      Logger.warn(
+        `[CalendarAdminService] Missing patient ID for appointment ${appointment.id}`
+      );
     }
-    // Add similar updates for patient and clinic calendar events
 
-    try {
-      await batch.commit();
-      Logger.info(
-        `[CalendarAdminService] Successfully updated calendar event times for appointment ${appointment.id}.`
+    // Update clinic calendar event
+    if (appointment.clinicBranchId) {
+      const clinicEventRef = this.db.doc(
+        `${CLINICS_COLLECTION}/${appointment.clinicBranchId}/${CALENDAR_COLLECTION}/${calendarEventId}`
       );
-    } catch (error) {
-      Logger.error(
-        `[CalendarAdminService] Error updating calendar event times for appointment ${appointment.id}:`,
-        error
+      batch.update(clinicEventRef, {
+        eventTime: firestoreCompatibleEventTime,
+        updatedAt: serverTimestamp,
+      });
+      updatesAdded++;
+      Logger.debug(
+        `[CalendarAdminService] Added clinic calendar event time update to batch`
+      );
+    } else {
+      Logger.warn(
+        `[CalendarAdminService] Missing clinic ID for appointment ${appointment.id}`
+      );
+    }
+
+    // Only commit if we have updates to make
+    if (updatesAdded > 0) {
+      try {
+        await batch.commit();
+        Logger.info(
+          `[CalendarAdminService] Successfully updated ${updatesAdded} calendar event times for appointment ${appointment.id}.`
+        );
+      } catch (error) {
+        Logger.error(
+          `[CalendarAdminService] Error updating calendar event times for appointment ${appointment.id}:`,
+          error
+        );
+        throw error; // Re-throw to allow caller to handle
+      }
+    } else {
+      Logger.warn(
+        `[CalendarAdminService] No calendar event time updates were made for appointment ${appointment.id}`
       );
     }
   }
@@ -154,26 +262,83 @@ export class CalendarAdminService {
       `[CalendarAdminService] Deleting calendar events for appointment ${appointment.id}`
     );
     const batch = this.db.batch();
+    let deletesAdded = 0;
 
-    // TODO: Confirm paths as in updateAppointmentCalendarEventsStatus
-    if (appointment.calendarEventId) {
-      // Practitioner event
+    // Get the shared calendar event ID
+    const calendarEventId = appointment.calendarEventId;
+
+    if (!calendarEventId) {
+      Logger.warn(
+        `[CalendarAdminService] Missing calendar event ID for appointment ${appointment.id}`
+      );
+      return;
+    }
+
+    // Delete practitioner calendar event
+    if (appointment.practitionerId) {
       const practitionerEventRef = this.db.doc(
-        `${PRACTITIONERS_COLLECTION}/${appointment.practitionerId}/${CALENDAR_COLLECTION}/${appointment.calendarEventId}`
+        `${PRACTITIONERS_COLLECTION}/${appointment.practitionerId}/${CALENDAR_COLLECTION}/${calendarEventId}`
       );
       batch.delete(practitionerEventRef);
+      deletesAdded++;
+      Logger.debug(
+        `[CalendarAdminService] Added practitioner calendar event deletion to batch`
+      );
+    } else {
+      Logger.warn(
+        `[CalendarAdminService] Missing practitioner ID for appointment ${appointment.id}`
+      );
     }
-    // Add similar deletes for patient and clinic calendar events
 
-    try {
-      await batch.commit();
-      Logger.info(
-        `[CalendarAdminService] Successfully deleted calendar events for appointment ${appointment.id}.`
+    // Delete patient calendar event
+    if (appointment.patientId) {
+      const patientEventRef = this.db.doc(
+        `${PATIENTS_COLLECTION}/${appointment.patientId}/${CALENDAR_COLLECTION}/${calendarEventId}`
+      );
+      batch.delete(patientEventRef);
+      deletesAdded++;
+      Logger.debug(
+        `[CalendarAdminService] Added patient calendar event deletion to batch`
+      );
+    } else {
+      Logger.warn(
+        `[CalendarAdminService] Missing patient ID for appointment ${appointment.id}`
       );
-    } catch (error) {
-      Logger.error(
-        `[CalendarAdminService] Error deleting calendar events for appointment ${appointment.id}:`,
-        error
+    }
+
+    // Delete clinic calendar event
+    if (appointment.clinicBranchId) {
+      const clinicEventRef = this.db.doc(
+        `${CLINICS_COLLECTION}/${appointment.clinicBranchId}/${CALENDAR_COLLECTION}/${calendarEventId}`
+      );
+      batch.delete(clinicEventRef);
+      deletesAdded++;
+      Logger.debug(
+        `[CalendarAdminService] Added clinic calendar event deletion to batch`
+      );
+    } else {
+      Logger.warn(
+        `[CalendarAdminService] Missing clinic ID for appointment ${appointment.id}`
+      );
+    }
+
+    // Only commit if we have deletions to make
+    if (deletesAdded > 0) {
+      try {
+        await batch.commit();
+        Logger.info(
+          `[CalendarAdminService] Successfully deleted ${deletesAdded} calendar events for appointment ${appointment.id}.`
+        );
+      } catch (error) {
+        Logger.error(
+          `[CalendarAdminService] Error deleting calendar events for appointment ${appointment.id}:`,
+          error
+        );
+        throw error; // Re-throw to allow caller to handle
+      }
+    } else {
+      Logger.warn(
+        `[CalendarAdminService] No calendar event deletions were made for appointment ${appointment.id}`
       );
     }
   }

package/src/services/calendar/calendar-refactored.service.ts

@@ -1142,6 +1142,7 @@ export class CalendarServiceV2 extends BaseService {
           CalendarEventStatus.CANCELED,
           CalendarEventStatus.COMPLETED,
           CalendarEventStatus.RESCHEDULED,
+          CalendarEventStatus.NO_SHOW,
         ],
         [CalendarEventStatus.REJECTED]: [],
         [CalendarEventStatus.CANCELED]: [],
@@ -1150,6 +1151,7 @@ export class CalendarServiceV2 extends BaseService {
           CalendarEventStatus.CANCELED,
         ],
         [CalendarEventStatus.COMPLETED]: [],
+        [CalendarEventStatus.NO_SHOW]: [],
       };
 
     // Check if transition is valid

package/src/services/patient/utils/medical.utils.ts

@@ -25,6 +25,7 @@ import {
   PATIENTS_COLLECTION,
   PATIENT_MEDICAL_INFO_COLLECTION,
   PatientDoctor,
+  type PatientProfile,
 } from "../../../types/patient";
 import {
   createPatientMedicalInfoSchema,
@@ -43,6 +44,7 @@ import { z } from "zod";
 import { AuthError } from "../../../errors/auth.errors";
 import { UserRole } from "../../../types";
 import { getMedicalInfoDocRef, getPatientDocRef } from "./docs.utils";
+import { getPractitionerProfileByUserRef } from "./practitioner.utils";
 
 // Pomoćna funkcija za proveru i inicijalizaciju medical info dokumenta
 export const ensureMedicalInfoExists = async (
@@ -117,32 +119,29 @@ const checkMedicalAccessUtil = async (
     throw new Error("Patient profile not found");
   }
 
-  const patientData = patientDoc.data();
+  const patientData = patientDoc.data() as PatientProfile;
 
   // Proveri da li je korisnik vlasnik profila
   if (patientData.userRef === userRef) return;
 
-  // Proveri da li korisnik ima potrebnu ulogu
-  if (
-    !(
-      userRoles.includes(UserRole.PRACTITIONER) ||
-      userRoles.includes(UserRole.PATIENT)
-    )
-  ) {
-    throw new AuthError(
-      "Nedozvoljen pristup medicinskim informacijama",
-      "AUTH/UNAUTHORIZED_ACCESS",
-      403
+  // Ako je doktor, proveri da li je povezan sa pacijentom
+  if (userRoles.includes(UserRole.PRACTITIONER)) {
+    const practitionerProfile = await getPractitionerProfileByUserRef(
+      db,
+      userRef
     );
-  }
 
-  // Ako je doktor, proveri da li je povezan sa pacijentom
-  if (
-    userRoles.includes(UserRole.PRACTITIONER) &&
-    !userRoles.includes(UserRole.PATIENT)
-  ) {
-    const isAssignedDoctor = patientData.doctors?.some(
-      (doctor: PatientDoctor) => doctor.userRef === userRef && doctor.isActive
+    if (!practitionerProfile) {
+      throw new AuthError(
+        "Practitioner profile not found",
+        "AUTH/UNAUTHORIZED_ACCESS",
+        403
+      );
+    }
+
+    // Check if practitioner's ID is in the patient's doctorIds array
+    const isAssignedDoctor = patientData.doctorIds?.includes(
+      practitionerProfile.id
     );
 
     if (!isAssignedDoctor) {
@@ -190,8 +189,10 @@ export const getMedicalInfoUtil = async (
     throw new Error("Medicinske informacije nisu pronađene");
   }
 
+  // The schema will transform raw timestamp objects to Timestamp instances
   return patientMedicalInfoSchema.parse(snapshot.data());
 };
+
 // Funkcije za rad sa vitalnim statistikama
 export const updateVitalStatsUtil = async (
   db: Firestore,
@@ -235,10 +236,12 @@ export const updateAllergyUtil = async (
   const validatedData = updateAllergySchema.parse(data);
   const { allergyIndex, ...updateData } = validatedData;
 
-  const doc = await getDoc(getMedicalInfoDocRef(db, patientId));
-  if (!doc.exists()) throw new Error("Medical info not found");
+  const docSnapshot = await getDoc(getMedicalInfoDocRef(db, patientId));
+  if (!docSnapshot.exists()) throw new Error("Medical info not found");
+
+  // Parse through schema to ensure proper Timestamp objects
+  const medicalInfo = patientMedicalInfoSchema.parse(docSnapshot.data());
 
-  const medicalInfo = doc.data() as PatientMedicalInfo;
   if (allergyIndex >= medicalInfo.allergies.length) {
     throw new Error("Invalid allergy index");
   }

package/src/services/patient/utils/practitioner.utils.ts

@@ -17,6 +17,10 @@ import {
   PATIENTS_COLLECTION,
 } from "../../../types/patient";
 import { getSensitiveInfoDocRef } from "./docs.utils";
+import {
+  Practitioner,
+  PRACTITIONERS_COLLECTION,
+} from "../../../types/practitioner";
 
 /**
  * Retrieves all patients associated with a specific practitioner with pagination support.
@@ -156,3 +160,101 @@ export const getPatientsByPractitionerWithDetailsUtil = async (
     );
   }
 };
+
+/**
+ * Retrieves a practitioner profile by ID
+ *
+ * @param {Firestore} db - Firestore instance
+ * @param {string} practitionerId - ID of the practitioner to retrieve
+ * @returns {Promise<Practitioner | null>} A promise resolving to the practitioner profile or null if not found
+ */
+export const getPractitionerProfile = async (
+  db: Firestore,
+  practitionerId: string
+): Promise<Practitioner | null> => {
+  try {
+    console.log(
+      `[getPractitionerProfile] Fetching practitioner with ID: ${practitionerId}`
+    );
+
+    const practitionerRef = doc(db, PRACTITIONERS_COLLECTION, practitionerId);
+    const practitionerSnapshot = await getDoc(practitionerRef);
+
+    if (!practitionerSnapshot.exists()) {
+      console.log(
+        `[getPractitionerProfile] Practitioner with ID ${practitionerId} not found`
+      );
+      return null;
+    }
+
+    const practitioner = practitionerSnapshot.data() as Practitioner;
+    console.log(
+      `[getPractitionerProfile] Successfully retrieved practitioner: ${practitioner.basicInfo.firstName} ${practitioner.basicInfo.lastName}`
+    );
+
+    return practitioner;
+  } catch (error) {
+    console.error(
+      `[getPractitionerProfile] Error fetching practitioner:`,
+      error
+    );
+    throw new Error(
+      `Failed to retrieve practitioner: ${
+        error instanceof Error ? error.message : String(error)
+      }`
+    );
+  }
+};
+
+/**
+ * Retrieves a practitioner profile by user reference ID
+ *
+ * @param {Firestore} db - Firestore instance
+ * @param {string} userRef - Firebase Auth user ID reference
+ * @returns {Promise<Practitioner | null>} A promise resolving to the practitioner profile or null if not found
+ */
+export const getPractitionerProfileByUserRef = async (
+  db: Firestore,
+  userRef: string
+): Promise<Practitioner | null> => {
+  try {
+    console.log(
+      `[getPractitionerProfileByUserRef] Fetching practitioner with userRef: ${userRef}`
+    );
+
+    const practitionersCollection = collection(db, PRACTITIONERS_COLLECTION);
+    const q = query(
+      practitionersCollection,
+      where("userRef", "==", userRef),
+      limit(1)
+    );
+
+    const querySnapshot = await getDocs(q);
+
+    if (querySnapshot.empty) {
+      console.log(
+        `[getPractitionerProfileByUserRef] No practitioner found with userRef: ${userRef}`
+      );
+      return null;
+    }
+
+    const practitionerDoc = querySnapshot.docs[0];
+    const practitioner = practitionerDoc.data() as Practitioner;
+
+    console.log(
+      `[getPractitionerProfileByUserRef] Successfully retrieved practitioner: ${practitioner.basicInfo.firstName} ${practitioner.basicInfo.lastName}`
+    );
+
+    return practitioner;
+  } catch (error) {
+    console.error(
+      `[getPractitionerProfileByUserRef] Error fetching practitioner:`,
+      error
+    );
+    throw new Error(
+      `Failed to retrieve practitioner by userRef: ${
+        error instanceof Error ? error.message : String(error)
+      }`
+    );
+  }
+};

package/src/types/calendar/index.ts

@@ -27,6 +27,7 @@ export enum CalendarEventStatus {
   CANCELED = "canceled", // When event is canceled by the patient
   RESCHEDULED = "rescheduled", // When event is rescheduled by the clinic administrator
   COMPLETED = "completed", // When event is completed
+  NO_SHOW = "no_show", // When event is no-show by the patient
 }
 
 /**

package/src/types/patient/medical-info.types.ts

@@ -34,7 +34,7 @@ export interface PatientMedicalInfo {
     condition: BlockingCondition;
     diagnosedAt: Timestamp;
     isActive: boolean;
-    notes?: string;
+    notes?: string | null;
   }[];
 
   contraindications: {
@@ -42,7 +42,7 @@ export interface PatientMedicalInfo {
     lastOccurrence: Timestamp;
     frequency: "rare" | "occasional" | "frequent";
     isActive: boolean;
-    notes?: string;
+    notes?: string | null;
   }[];
 
   allergies: Allergy[];

package/src/validations/common.schema.ts

@@ -1,9 +1,20 @@
 import { z } from "zod";
 import { Timestamp } from "firebase/firestore";
 
-export const timestampSchema = z.object({
-  seconds: z.number(),
-  nanoseconds: z.number(),
-});
+// Create a custom schema for Timestamp that properly handles both raw objects and Timestamp instances
+export const timestampSchema = z
+  .union([
+    z.object({
+      seconds: z.number(),
+      nanoseconds: z.number(),
+    }),
+    z.instanceof(Timestamp),
+  ])
+  .transform((data) => {
+    if (data instanceof Timestamp) {
+      return data;
+    }
+    return new Timestamp(data.seconds, data.nanoseconds);
+  });
 
 // export const timestampSchema = z.instanceof(Timestamp);