@blackcode_sa/metaestetics-api 1.13.19 → 1.13.21

package/dist/index.js

@@ -4606,7 +4606,7 @@ async function updateAppointmentUtil(db, appointmentId, data) {
         updateData.confirmationTime = import_firestore6.Timestamp.now();
       }
       if (currentAppointment.calendarEventId) {
-        await updateCalendarEventStatus(db, currentAppointment.calendarEventId, data.status);
+        await updateCalendarEventStatus(db, currentAppointment, data.status);
       }
     }
     await (0, import_firestore6.updateDoc)(appointmentRef, updateData);
@@ -4620,12 +4620,11 @@ async function updateAppointmentUtil(db, appointmentId, data) {
     throw error;
   }
 }
-async function updateCalendarEventStatus(db, calendarEventId, appointmentStatus) {
+async function updateCalendarEventStatus(db, appointment, appointmentStatus) {
   try {
-    const calendarEventRef = (0, import_firestore6.doc)(db, CALENDAR_COLLECTION, calendarEventId);
-    const calendarEventDoc = await (0, import_firestore6.getDoc)(calendarEventRef);
-    if (!calendarEventDoc.exists()) {
-      console.warn(`Calendar event with ID ${calendarEventId} not found`);
+    const calendarEventId = appointment.calendarEventId;
+    if (!calendarEventId) {
+      console.warn(`Appointment ${appointment.id} has no calendarEventId, skipping calendar event update`);
       return;
     }
     let calendarStatus;
@@ -4660,12 +4659,48 @@ async function updateCalendarEventStatus(db, calendarEventId, appointmentStatus)
         console.warn(`Unknown appointment status: ${appointmentStatus}, not updating calendar event`);
         return;
     }
-    await (0, import_firestore6.updateDoc)(calendarEventRef, {
+    const updateData = {
       status: calendarStatus,
       updatedAt: (0, import_firestore6.serverTimestamp)()
-    });
+    };
+    const updatePromises = [];
+    if (appointment.practitionerId) {
+      const practitionerEventRef = (0, import_firestore6.doc)(
+        db,
+        `${PRACTITIONERS_COLLECTION}/${appointment.practitionerId}/${CALENDAR_COLLECTION}/${calendarEventId}`
+      );
+      updatePromises.push(
+        (0, import_firestore6.updateDoc)(practitionerEventRef, updateData).catch((error) => {
+          console.error(`Error updating practitioner calendar event ${calendarEventId}:`, error);
+        })
+      );
+    }
+    if (appointment.patientId) {
+      const patientEventRef = (0, import_firestore6.doc)(
+        db,
+        `${PATIENTS_COLLECTION}/${appointment.patientId}/${CALENDAR_COLLECTION}/${calendarEventId}`
+      );
+      updatePromises.push(
+        (0, import_firestore6.updateDoc)(patientEventRef, updateData).catch((error) => {
+          console.error(`Error updating patient calendar event ${calendarEventId}:`, error);
+        })
+      );
+    }
+    if (appointment.clinicBranchId) {
+      const clinicEventRef = (0, import_firestore6.doc)(
+        db,
+        `${CLINICS_COLLECTION}/${appointment.clinicBranchId}/${CALENDAR_COLLECTION}/${calendarEventId}`
+      );
+      updatePromises.push(
+        (0, import_firestore6.updateDoc)(clinicEventRef, updateData).catch((error) => {
+          console.error(`Error updating clinic calendar event ${calendarEventId}:`, error);
+        })
+      );
+    }
+    await Promise.all(updatePromises);
+    console.log(`Successfully updated calendar event ${calendarEventId} status to ${calendarStatus} across all collections`);
   } catch (error) {
-    console.error(`Error updating calendar event ${calendarEventId}:`, error);
+    console.error(`Error updating calendar events for appointment ${appointment.id}:`, error);
   }
 }
 async function getAppointmentByIdUtil(db, appointmentId) {
@@ -7803,7 +7838,7 @@ var contraindicationSchema = import_zod6.z.object({
   notes: import_zod6.z.string().optional().nullable(),
   isActive: import_zod6.z.boolean()
 });
-var medicationSchema = import_zod6.z.object({
+var baseMedicationSchema = import_zod6.z.object({
   name: import_zod6.z.string().min(1),
   dosage: import_zod6.z.string().min(1),
   frequency: import_zod6.z.string().min(1),
@@ -7811,6 +7846,24 @@ var medicationSchema = import_zod6.z.object({
   endDate: timestampSchema.optional().nullable(),
   prescribedBy: import_zod6.z.string().optional().nullable()
 });
+var medicationSchema = baseMedicationSchema.refine(
+  (data) => {
+    if (!data.endDate) {
+      return true;
+    }
+    if (!data.startDate) {
+      return false;
+    }
+    const startDate = data.startDate.toDate();
+    const endDate = data.endDate.toDate();
+    return endDate >= startDate;
+  },
+  {
+    message: "End date requires a start date and must be equal to or after start date",
+    path: ["endDate"]
+    // This will attach the error to the endDate field
+  }
+);
 var patientMedicalInfoSchema = import_zod6.z.object({
   patientId: import_zod6.z.string(),
   vitalStats: vitalStatsSchema,
@@ -7846,9 +7899,26 @@ var updateContraindicationSchema = contraindicationSchema.partial().extend({
   contraindicationIndex: import_zod6.z.number().min(0)
 });
 var addMedicationSchema = medicationSchema;
-var updateMedicationSchema = medicationSchema.partial().extend({
+var updateMedicationSchema = baseMedicationSchema.partial().extend({
   medicationIndex: import_zod6.z.number().min(0)
-});
+}).refine(
+  (data) => {
+    if (!data.endDate) {
+      return true;
+    }
+    if (!data.startDate) {
+      return false;
+    }
+    const startDate = data.startDate.toDate();
+    const endDate = data.endDate.toDate();
+    return endDate >= startDate;
+  },
+  {
+    message: "End date requires a start date and must be equal to or after start date",
+    path: ["endDate"]
+    // This will attach the error to the endDate field
+  }
+);
 
 // src/validations/patient.schema.ts
 var locationDataSchema = import_zod7.z.object({
@@ -12280,6 +12350,9 @@ var PractitionerService = class extends BaseService {
    */
   async EnableFreeConsultation(practitionerId, clinicId) {
     try {
+      console.log(
+        `[EnableFreeConsultation] Starting for practitioner ${practitionerId} in clinic ${clinicId}`
+      );
       await this.ensureFreeConsultationInfrastructure();
       const practitioner = await this.getPractitioner(practitionerId);
       if (!practitioner) {
@@ -12295,32 +12368,83 @@ var PractitionerService = class extends BaseService {
         );
       }
       const [activeProcedures, inactiveProcedures] = await Promise.all([
-        this.getProcedureService().getProceduresByPractitioner(practitionerId),
+        this.getProcedureService().getProceduresByPractitioner(
+          practitionerId,
+          void 0,
+          // clinicBranchId
+          false
+          // excludeDraftPractitioners - allow draft practitioners
+        ),
         this.getProcedureService().getInactiveProceduresByPractitioner(
           practitionerId
         )
       ]);
       const allProcedures = [...activeProcedures, ...inactiveProcedures];
-      const existingConsultation = allProcedures.find(
+      const existingConsultations = allProcedures.filter(
         (procedure) => procedure.technology.id === "free-consultation-tech" && procedure.clinicBranchId === clinicId
       );
+      console.log(
+        `[EnableFreeConsultation] Found ${existingConsultations.length} existing free consultation(s)`
+      );
+      if (existingConsultations.length > 1) {
+        console.warn(
+          `[EnableFreeConsultation] WARNING: Found ${existingConsultations.length} duplicate free consultations for practitioner ${practitionerId} in clinic ${clinicId}`
+        );
+        for (let i = 1; i < existingConsultations.length; i++) {
+          console.log(
+            `[EnableFreeConsultation] Deactivating duplicate consultation ${existingConsultations[i].id}`
+          );
+          await this.getProcedureService().deactivateProcedure(
+            existingConsultations[i].id
+          );
+        }
+      }
+      const existingConsultation = existingConsultations[0];
       if (existingConsultation) {
         if (existingConsultation.isActive) {
           console.log(
-            `Free consultation already active for practitioner ${practitionerId} in clinic ${clinicId}`
+            `[EnableFreeConsultation] Free consultation already active for practitioner ${practitionerId} in clinic ${clinicId}`
           );
           return;
         } else {
+          console.log(
+            `[EnableFreeConsultation] Reactivating existing consultation ${existingConsultation.id}`
+          );
           await this.getProcedureService().updateProcedure(
             existingConsultation.id,
             { isActive: true }
           );
           console.log(
-            `Reactivated existing free consultation for practitioner ${practitionerId} in clinic ${clinicId}`
+            `[EnableFreeConsultation] Reactivated existing free consultation for practitioner ${practitionerId} in clinic ${clinicId}`
           );
           return;
         }
       }
+      console.log(
+        `[EnableFreeConsultation] Final race condition check before creating new procedure`
+      );
+      const finalCheckProcedures = await this.getProcedureService().getProceduresByPractitioner(
+        practitionerId,
+        void 0,
+        // clinicBranchId
+        false
+        // excludeDraftPractitioners - allow draft practitioners
+      );
+      const raceConditionCheck = finalCheckProcedures.find(
+        (procedure) => procedure.technology.id === "free-consultation-tech" && procedure.clinicBranchId === clinicId
+      );
+      if (raceConditionCheck) {
+        console.log(
+          `[EnableFreeConsultation] Race condition detected! Procedure was created by another request. Using existing procedure ${raceConditionCheck.id}`
+        );
+        if (!raceConditionCheck.isActive) {
+          await this.getProcedureService().updateProcedure(
+            raceConditionCheck.id,
+            { isActive: true }
+          );
+        }
+        return;
+      }
       const consultationData = {
         name: "Free Consultation",
         nameLower: "free consultation",
@@ -12340,15 +12464,18 @@ var PractitionerService = class extends BaseService {
         photos: []
         // No photos for consultation
       };
+      console.log(
+        `[EnableFreeConsultation] Creating new free consultation procedure`
+      );
       await this.getProcedureService().createConsultationProcedure(
         consultationData
       );
       console.log(
-        `Free consultation enabled for practitioner ${practitionerId} in clinic ${clinicId}`
+        `[EnableFreeConsultation] Successfully created free consultation for practitioner ${practitionerId} in clinic ${clinicId}`
       );
     } catch (error) {
       console.error(
-        `Error enabling free consultation for practitioner ${practitionerId} in clinic ${clinicId}:`,
+        `[EnableFreeConsultation] Error enabling free consultation for practitioner ${practitionerId} in clinic ${clinicId}:`,
         error
       );
       throw error;
@@ -12444,17 +12571,40 @@ var PractitionerService = class extends BaseService {
         );
       }
       const existingProcedures = await this.getProcedureService().getProceduresByPractitioner(
-        practitionerId
+        practitionerId,
+        void 0,
+        // clinicBranchId (optional)
+        false
+        // excludeDraftPractitioners - must be false to find procedures for draft practitioners
+      );
+      console.log(
+        `[DisableFreeConsultation] Found ${existingProcedures.length} procedures for practitioner ${practitionerId}`
       );
       const freeConsultation = existingProcedures.find(
         (procedure) => procedure.technology.id === "free-consultation-tech" && procedure.clinicBranchId === clinicId && procedure.isActive
       );
       if (!freeConsultation) {
         console.log(
-          `No active free consultation found for practitioner ${practitionerId} in clinic ${clinicId}`
+          `[DisableFreeConsultation] No active free consultation found for practitioner ${practitionerId} in clinic ${clinicId}`
+        );
+        console.log(
+          `[DisableFreeConsultation] Existing procedures:`,
+          existingProcedures.map((p) => {
+            var _a;
+            return {
+              id: p.id,
+              name: p.name,
+              technologyId: (_a = p.technology) == null ? void 0 : _a.id,
+              clinicBranchId: p.clinicBranchId,
+              isActive: p.isActive
+            };
+          })
         );
         return;
       }
+      console.log(
+        `[DisableFreeConsultation] Found free consultation procedure ${freeConsultation.id}, deactivating...`
+      );
       await this.getProcedureService().deactivateProcedure(freeConsultation.id);
       console.log(
         `Free consultation disabled for practitioner ${practitionerId} in clinic ${clinicId}`

package/dist/index.mjs

@@ -4493,7 +4493,7 @@ async function updateAppointmentUtil(db, appointmentId, data) {
         updateData.confirmationTime = Timestamp5.now();
       }
       if (currentAppointment.calendarEventId) {
-        await updateCalendarEventStatus(db, currentAppointment.calendarEventId, data.status);
+        await updateCalendarEventStatus(db, currentAppointment, data.status);
       }
     }
     await updateDoc2(appointmentRef, updateData);
@@ -4507,12 +4507,11 @@ async function updateAppointmentUtil(db, appointmentId, data) {
     throw error;
   }
 }
-async function updateCalendarEventStatus(db, calendarEventId, appointmentStatus) {
+async function updateCalendarEventStatus(db, appointment, appointmentStatus) {
   try {
-    const calendarEventRef = doc4(db, CALENDAR_COLLECTION, calendarEventId);
-    const calendarEventDoc = await getDoc4(calendarEventRef);
-    if (!calendarEventDoc.exists()) {
-      console.warn(`Calendar event with ID ${calendarEventId} not found`);
+    const calendarEventId = appointment.calendarEventId;
+    if (!calendarEventId) {
+      console.warn(`Appointment ${appointment.id} has no calendarEventId, skipping calendar event update`);
       return;
     }
     let calendarStatus;
@@ -4547,12 +4546,48 @@ async function updateCalendarEventStatus(db, calendarEventId, appointmentStatus)
         console.warn(`Unknown appointment status: ${appointmentStatus}, not updating calendar event`);
         return;
     }
-    await updateDoc2(calendarEventRef, {
+    const updateData = {
       status: calendarStatus,
       updatedAt: serverTimestamp()
-    });
+    };
+    const updatePromises = [];
+    if (appointment.practitionerId) {
+      const practitionerEventRef = doc4(
+        db,
+        `${PRACTITIONERS_COLLECTION}/${appointment.practitionerId}/${CALENDAR_COLLECTION}/${calendarEventId}`
+      );
+      updatePromises.push(
+        updateDoc2(practitionerEventRef, updateData).catch((error) => {
+          console.error(`Error updating practitioner calendar event ${calendarEventId}:`, error);
+        })
+      );
+    }
+    if (appointment.patientId) {
+      const patientEventRef = doc4(
+        db,
+        `${PATIENTS_COLLECTION}/${appointment.patientId}/${CALENDAR_COLLECTION}/${calendarEventId}`
+      );
+      updatePromises.push(
+        updateDoc2(patientEventRef, updateData).catch((error) => {
+          console.error(`Error updating patient calendar event ${calendarEventId}:`, error);
+        })
+      );
+    }
+    if (appointment.clinicBranchId) {
+      const clinicEventRef = doc4(
+        db,
+        `${CLINICS_COLLECTION}/${appointment.clinicBranchId}/${CALENDAR_COLLECTION}/${calendarEventId}`
+      );
+      updatePromises.push(
+        updateDoc2(clinicEventRef, updateData).catch((error) => {
+          console.error(`Error updating clinic calendar event ${calendarEventId}:`, error);
+        })
+      );
+    }
+    await Promise.all(updatePromises);
+    console.log(`Successfully updated calendar event ${calendarEventId} status to ${calendarStatus} across all collections`);
   } catch (error) {
-    console.error(`Error updating calendar event ${calendarEventId}:`, error);
+    console.error(`Error updating calendar events for appointment ${appointment.id}:`, error);
   }
 }
 async function getAppointmentByIdUtil(db, appointmentId) {
@@ -7743,7 +7778,7 @@ var contraindicationSchema = z6.object({
   notes: z6.string().optional().nullable(),
   isActive: z6.boolean()
 });
-var medicationSchema = z6.object({
+var baseMedicationSchema = z6.object({
   name: z6.string().min(1),
   dosage: z6.string().min(1),
   frequency: z6.string().min(1),
@@ -7751,6 +7786,24 @@ var medicationSchema = z6.object({
   endDate: timestampSchema.optional().nullable(),
   prescribedBy: z6.string().optional().nullable()
 });
+var medicationSchema = baseMedicationSchema.refine(
+  (data) => {
+    if (!data.endDate) {
+      return true;
+    }
+    if (!data.startDate) {
+      return false;
+    }
+    const startDate = data.startDate.toDate();
+    const endDate = data.endDate.toDate();
+    return endDate >= startDate;
+  },
+  {
+    message: "End date requires a start date and must be equal to or after start date",
+    path: ["endDate"]
+    // This will attach the error to the endDate field
+  }
+);
 var patientMedicalInfoSchema = z6.object({
   patientId: z6.string(),
   vitalStats: vitalStatsSchema,
@@ -7786,9 +7839,26 @@ var updateContraindicationSchema = contraindicationSchema.partial().extend({
   contraindicationIndex: z6.number().min(0)
 });
 var addMedicationSchema = medicationSchema;
-var updateMedicationSchema = medicationSchema.partial().extend({
+var updateMedicationSchema = baseMedicationSchema.partial().extend({
   medicationIndex: z6.number().min(0)
-});
+}).refine(
+  (data) => {
+    if (!data.endDate) {
+      return true;
+    }
+    if (!data.startDate) {
+      return false;
+    }
+    const startDate = data.startDate.toDate();
+    const endDate = data.endDate.toDate();
+    return endDate >= startDate;
+  },
+  {
+    message: "End date requires a start date and must be equal to or after start date",
+    path: ["endDate"]
+    // This will attach the error to the endDate field
+  }
+);
 
 // src/validations/patient.schema.ts
 var locationDataSchema = z7.object({
@@ -12303,6 +12373,9 @@ var PractitionerService = class extends BaseService {
    */
   async EnableFreeConsultation(practitionerId, clinicId) {
     try {
+      console.log(
+        `[EnableFreeConsultation] Starting for practitioner ${practitionerId} in clinic ${clinicId}`
+      );
       await this.ensureFreeConsultationInfrastructure();
       const practitioner = await this.getPractitioner(practitionerId);
       if (!practitioner) {
@@ -12318,32 +12391,83 @@ var PractitionerService = class extends BaseService {
         );
       }
       const [activeProcedures, inactiveProcedures] = await Promise.all([
-        this.getProcedureService().getProceduresByPractitioner(practitionerId),
+        this.getProcedureService().getProceduresByPractitioner(
+          practitionerId,
+          void 0,
+          // clinicBranchId
+          false
+          // excludeDraftPractitioners - allow draft practitioners
+        ),
         this.getProcedureService().getInactiveProceduresByPractitioner(
           practitionerId
         )
       ]);
       const allProcedures = [...activeProcedures, ...inactiveProcedures];
-      const existingConsultation = allProcedures.find(
+      const existingConsultations = allProcedures.filter(
         (procedure) => procedure.technology.id === "free-consultation-tech" && procedure.clinicBranchId === clinicId
       );
+      console.log(
+        `[EnableFreeConsultation] Found ${existingConsultations.length} existing free consultation(s)`
+      );
+      if (existingConsultations.length > 1) {
+        console.warn(
+          `[EnableFreeConsultation] WARNING: Found ${existingConsultations.length} duplicate free consultations for practitioner ${practitionerId} in clinic ${clinicId}`
+        );
+        for (let i = 1; i < existingConsultations.length; i++) {
+          console.log(
+            `[EnableFreeConsultation] Deactivating duplicate consultation ${existingConsultations[i].id}`
+          );
+          await this.getProcedureService().deactivateProcedure(
+            existingConsultations[i].id
+          );
+        }
+      }
+      const existingConsultation = existingConsultations[0];
       if (existingConsultation) {
         if (existingConsultation.isActive) {
           console.log(
-            `Free consultation already active for practitioner ${practitionerId} in clinic ${clinicId}`
+            `[EnableFreeConsultation] Free consultation already active for practitioner ${practitionerId} in clinic ${clinicId}`
           );
           return;
         } else {
+          console.log(
+            `[EnableFreeConsultation] Reactivating existing consultation ${existingConsultation.id}`
+          );
           await this.getProcedureService().updateProcedure(
             existingConsultation.id,
             { isActive: true }
           );
           console.log(
-            `Reactivated existing free consultation for practitioner ${practitionerId} in clinic ${clinicId}`
+            `[EnableFreeConsultation] Reactivated existing free consultation for practitioner ${practitionerId} in clinic ${clinicId}`
           );
           return;
         }
       }
+      console.log(
+        `[EnableFreeConsultation] Final race condition check before creating new procedure`
+      );
+      const finalCheckProcedures = await this.getProcedureService().getProceduresByPractitioner(
+        practitionerId,
+        void 0,
+        // clinicBranchId
+        false
+        // excludeDraftPractitioners - allow draft practitioners
+      );
+      const raceConditionCheck = finalCheckProcedures.find(
+        (procedure) => procedure.technology.id === "free-consultation-tech" && procedure.clinicBranchId === clinicId
+      );
+      if (raceConditionCheck) {
+        console.log(
+          `[EnableFreeConsultation] Race condition detected! Procedure was created by another request. Using existing procedure ${raceConditionCheck.id}`
+        );
+        if (!raceConditionCheck.isActive) {
+          await this.getProcedureService().updateProcedure(
+            raceConditionCheck.id,
+            { isActive: true }
+          );
+        }
+        return;
+      }
       const consultationData = {
         name: "Free Consultation",
         nameLower: "free consultation",
@@ -12363,15 +12487,18 @@ var PractitionerService = class extends BaseService {
         photos: []
         // No photos for consultation
       };
+      console.log(
+        `[EnableFreeConsultation] Creating new free consultation procedure`
+      );
       await this.getProcedureService().createConsultationProcedure(
         consultationData
       );
       console.log(
-        `Free consultation enabled for practitioner ${practitionerId} in clinic ${clinicId}`
+        `[EnableFreeConsultation] Successfully created free consultation for practitioner ${practitionerId} in clinic ${clinicId}`
       );
     } catch (error) {
       console.error(
-        `Error enabling free consultation for practitioner ${practitionerId} in clinic ${clinicId}:`,
+        `[EnableFreeConsultation] Error enabling free consultation for practitioner ${practitionerId} in clinic ${clinicId}:`,
         error
       );
       throw error;
@@ -12467,17 +12594,40 @@ var PractitionerService = class extends BaseService {
         );
       }
       const existingProcedures = await this.getProcedureService().getProceduresByPractitioner(
-        practitionerId
+        practitionerId,
+        void 0,
+        // clinicBranchId (optional)
+        false
+        // excludeDraftPractitioners - must be false to find procedures for draft practitioners
+      );
+      console.log(
+        `[DisableFreeConsultation] Found ${existingProcedures.length} procedures for practitioner ${practitionerId}`
       );
       const freeConsultation = existingProcedures.find(
         (procedure) => procedure.technology.id === "free-consultation-tech" && procedure.clinicBranchId === clinicId && procedure.isActive
       );
       if (!freeConsultation) {
         console.log(
-          `No active free consultation found for practitioner ${practitionerId} in clinic ${clinicId}`
+          `[DisableFreeConsultation] No active free consultation found for practitioner ${practitionerId} in clinic ${clinicId}`
+        );
+        console.log(
+          `[DisableFreeConsultation] Existing procedures:`,
+          existingProcedures.map((p) => {
+            var _a;
+            return {
+              id: p.id,
+              name: p.name,
+              technologyId: (_a = p.technology) == null ? void 0 : _a.id,
+              clinicBranchId: p.clinicBranchId,
+              isActive: p.isActive
+            };
+          })
         );
         return;
       }
+      console.log(
+        `[DisableFreeConsultation] Found free consultation procedure ${freeConsultation.id}, deactivating...`
+      );
       await this.getProcedureService().deactivateProcedure(freeConsultation.id);
       console.log(
         `Free consultation disabled for practitioner ${practitionerId} in clinic ${clinicId}`

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@blackcode_sa/metaestetics-api",
   "private": false,
-  "version": "1.13.19",
+  "version": "1.13.21",
   "description": "Firebase authentication service with anonymous upgrade support",
   "main": "dist/index.js",
   "module": "dist/index.mjs",

package/src/services/appointment/utils/appointment.utils.ts

@@ -28,6 +28,9 @@ import {
 import { CalendarEvent, CALENDAR_COLLECTION } from '../../../types/calendar';
 import { ProcedureSummaryInfo } from '../../../types/procedure';
 import { ClinicInfo, PatientProfileInfo, PractitionerProfileInfo } from '../../../types/profile';
+import { PRACTITIONERS_COLLECTION } from '../../../types/practitioner';
+import { PATIENTS_COLLECTION } from '../../../types/patient';
+import { CLINICS_COLLECTION } from '../../../types/clinic';
 import { BlockingCondition } from '../../../backoffice/types/static/blocking-condition.types';
 import { Requirement } from '../../../backoffice/types/requirement.types';
 import { PRACTITIONERS_COLLECTION } from '../../../types/practitioner';
@@ -379,7 +382,7 @@ export async function updateAppointmentUtil(
 
       // Update the related calendar event status if needed
       if (currentAppointment.calendarEventId) {
-        await updateCalendarEventStatus(db, currentAppointment.calendarEventId, data.status);
+        await updateCalendarEventStatus(db, currentAppointment, data.status);
       }
     }
 
@@ -400,28 +403,27 @@ export async function updateAppointmentUtil(
 }
 
 /**
- * Updates the status of a calendar event based on appointment status changes.
+ * Updates the status of calendar events across all collections (practitioner, patient, clinic)
+ * based on appointment status changes.
  *
  * @param db Firestore instance
- * @param calendarEventId ID of the calendar event
+ * @param appointment The appointment object containing calendar event references
  * @param appointmentStatus New appointment status
  */
 async function updateCalendarEventStatus(
   db: Firestore,
-  calendarEventId: string,
+  appointment: Appointment,
   appointmentStatus: AppointmentStatus,
 ): Promise<void> {
   try {
-    const calendarEventRef = doc(db, CALENDAR_COLLECTION, calendarEventId);
-    const calendarEventDoc = await getDoc(calendarEventRef);
-
-    if (!calendarEventDoc.exists()) {
-      console.warn(`Calendar event with ID ${calendarEventId} not found`);
+    const calendarEventId = appointment.calendarEventId;
+    if (!calendarEventId) {
+      console.warn(`Appointment ${appointment.id} has no calendarEventId, skipping calendar event update`);
       return;
     }
 
     // Map appointment status to calendar event status
-    let calendarStatus;
+    let calendarStatus: string;
     switch (appointmentStatus) {
       case AppointmentStatus.PENDING:
         calendarStatus = 'pending';
@@ -455,12 +457,58 @@ async function updateCalendarEventStatus(
         return;
     }
 
-    await updateDoc(calendarEventRef, {
+    const updateData = {
       status: calendarStatus,
       updatedAt: serverTimestamp(),
-    });
+    };
+
+    // Update all three calendar event collections in parallel
+    const updatePromises: Promise<void>[] = [];
+
+    // Update practitioner calendar event
+    if (appointment.practitionerId) {
+      const practitionerEventRef = doc(
+        db,
+        `${PRACTITIONERS_COLLECTION}/${appointment.practitionerId}/${CALENDAR_COLLECTION}/${calendarEventId}`
+      );
+      updatePromises.push(
+        updateDoc(practitionerEventRef, updateData).catch(error => {
+          console.error(`Error updating practitioner calendar event ${calendarEventId}:`, error);
+        })
+      );
+    }
+
+    // Update patient calendar event
+    if (appointment.patientId) {
+      const patientEventRef = doc(
+        db,
+        `${PATIENTS_COLLECTION}/${appointment.patientId}/${CALENDAR_COLLECTION}/${calendarEventId}`
+      );
+      updatePromises.push(
+        updateDoc(patientEventRef, updateData).catch(error => {
+          console.error(`Error updating patient calendar event ${calendarEventId}:`, error);
+        })
+      );
+    }
+
+    // Update clinic calendar event
+    if (appointment.clinicBranchId) {
+      const clinicEventRef = doc(
+        db,
+        `${CLINICS_COLLECTION}/${appointment.clinicBranchId}/${CALENDAR_COLLECTION}/${calendarEventId}`
+      );
+      updatePromises.push(
+        updateDoc(clinicEventRef, updateData).catch(error => {
+          console.error(`Error updating clinic calendar event ${calendarEventId}:`, error);
+        })
+      );
+    }
+
+    // Wait for all updates to complete
+    await Promise.all(updatePromises);
+    console.log(`Successfully updated calendar event ${calendarEventId} status to ${calendarStatus} across all collections`);
   } catch (error) {
-    console.error(`Error updating calendar event ${calendarEventId}:`, error);
+    console.error(`Error updating calendar events for appointment ${appointment.id}:`, error);
     // Don't throw error to avoid failing the appointment update
   }
 }

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

@@ -1546,6 +1546,10 @@ export class PractitionerService extends BaseService {
     clinicId: string
   ): Promise<void> {
     try {
+      console.log(
+        `[EnableFreeConsultation] Starting for practitioner ${practitionerId} in clinic ${clinicId}`
+      );
+
       // First, ensure the free consultation infrastructure exists
       await this.ensureFreeConsultationInfrastructure();
 
@@ -1573,9 +1577,15 @@ export class PractitionerService extends BaseService {
         );
       }
 
-      // Get all procedures for this practitioner (including inactive ones)
+      // CRITICAL: Double-check for existing procedures to prevent race conditions
+      // Fetch procedures again right before creation/update
+      // IMPORTANT: Pass false for excludeDraftPractitioners to work with draft practitioners
       const [activeProcedures, inactiveProcedures] = await Promise.all([
-        this.getProcedureService().getProceduresByPractitioner(practitionerId),
+        this.getProcedureService().getProceduresByPractitioner(
+          practitionerId,
+          undefined, // clinicBranchId
+          false // excludeDraftPractitioners - allow draft practitioners
+        ),
         this.getProcedureService().getInactiveProceduresByPractitioner(
           practitionerId
         ),
@@ -1585,31 +1595,86 @@ export class PractitionerService extends BaseService {
       const allProcedures = [...activeProcedures, ...inactiveProcedures];
 
       // Check if free consultation already exists (active or inactive)
-      const existingConsultation = allProcedures.find(
+      const existingConsultations = allProcedures.filter(
         (procedure) =>
           procedure.technology.id === "free-consultation-tech" &&
           procedure.clinicBranchId === clinicId
       );
 
+      console.log(
+        `[EnableFreeConsultation] Found ${existingConsultations.length} existing free consultation(s)`
+      );
+
+      // If multiple consultations exist, log a warning and clean up duplicates
+      if (existingConsultations.length > 1) {
+        console.warn(
+          `[EnableFreeConsultation] WARNING: Found ${existingConsultations.length} duplicate free consultations for practitioner ${practitionerId} in clinic ${clinicId}`
+        );
+        // Keep the first one, deactivate the rest
+        for (let i = 1; i < existingConsultations.length; i++) {
+          console.log(
+            `[EnableFreeConsultation] Deactivating duplicate consultation ${existingConsultations[i].id}`
+          );
+          await this.getProcedureService().deactivateProcedure(
+            existingConsultations[i].id
+          );
+        }
+      }
+
+      const existingConsultation = existingConsultations[0];
+
       if (existingConsultation) {
         if (existingConsultation.isActive) {
           console.log(
-            `Free consultation already active for practitioner ${practitionerId} in clinic ${clinicId}`
+            `[EnableFreeConsultation] Free consultation already active for practitioner ${practitionerId} in clinic ${clinicId}`
           );
           return;
         } else {
           // Reactivate the existing disabled consultation
+          console.log(
+            `[EnableFreeConsultation] Reactivating existing consultation ${existingConsultation.id}`
+          );
           await this.getProcedureService().updateProcedure(
             existingConsultation.id,
             { isActive: true }
           );
           console.log(
-            `Reactivated existing free consultation for practitioner ${practitionerId} in clinic ${clinicId}`
+            `[EnableFreeConsultation] Reactivated existing free consultation for practitioner ${practitionerId} in clinic ${clinicId}`
           );
           return;
         }
       }
 
+      // Final check before creating - race condition guard
+      // Fetch one more time to ensure no procedure was created in parallel
+      console.log(
+        `[EnableFreeConsultation] Final race condition check before creating new procedure`
+      );
+      const finalCheckProcedures =
+        await this.getProcedureService().getProceduresByPractitioner(
+          practitionerId,
+          undefined, // clinicBranchId
+          false // excludeDraftPractitioners - allow draft practitioners
+        );
+      const raceConditionCheck = finalCheckProcedures.find(
+        (procedure) =>
+          procedure.technology.id === "free-consultation-tech" &&
+          procedure.clinicBranchId === clinicId
+      );
+
+      if (raceConditionCheck) {
+        console.log(
+          `[EnableFreeConsultation] Race condition detected! Procedure was created by another request. Using existing procedure ${raceConditionCheck.id}`
+        );
+        if (!raceConditionCheck.isActive) {
+          await this.getProcedureService().updateProcedure(
+            raceConditionCheck.id,
+            { isActive: true }
+          );
+        }
+        return;
+      }
+
       // Create procedure data for free consultation (without productId or productsMetadata)
       const consultationData: Omit<CreateProcedureData, "productId"> = {
         name: "Free Consultation",
@@ -1631,16 +1696,19 @@ export class PractitionerService extends BaseService {
       };
 
       // Create the consultation procedure using the special method
+      console.log(
+        `[EnableFreeConsultation] Creating new free consultation procedure`
+      );
       await this.getProcedureService().createConsultationProcedure(
         consultationData
       );
 
       console.log(
-        `Free consultation enabled for practitioner ${practitionerId} in clinic ${clinicId}`
+        `[EnableFreeConsultation] Successfully created free consultation for practitioner ${practitionerId} in clinic ${clinicId}`
       );
     } catch (error) {
       console.error(
-        `Error enabling free consultation for practitioner ${practitionerId} in clinic ${clinicId}:`,
+        `[EnableFreeConsultation] Error enabling free consultation for practitioner ${practitionerId} in clinic ${clinicId}:`,
         error
       );
       throw error;
@@ -1764,10 +1832,18 @@ export class PractitionerService extends BaseService {
 
       // Find the free consultation procedure for this practitioner in this clinic
       // Use the more specific search by technology ID instead of name
+      // IMPORTANT: Pass false for excludeDraftPractitioners to allow disabling for draft practitioners
       const existingProcedures =
         await this.getProcedureService().getProceduresByPractitioner(
-          practitionerId
+          practitionerId,
+          undefined, // clinicBranchId (optional)
+          false // excludeDraftPractitioners - must be false to find procedures for draft practitioners
         );
+      
+      console.log(
+        `[DisableFreeConsultation] Found ${existingProcedures.length} procedures for practitioner ${practitionerId}`
+      );
+      
       const freeConsultation = existingProcedures.find(
         (procedure) =>
           procedure.technology.id === "free-consultation-tech" &&
@@ -1777,10 +1853,24 @@ export class PractitionerService extends BaseService {
 
       if (!freeConsultation) {
         console.log(
-          `No active free consultation found for practitioner ${practitionerId} in clinic ${clinicId}`
+          `[DisableFreeConsultation] No active free consultation found for practitioner ${practitionerId} in clinic ${clinicId}`
+        );
+        console.log(
+          `[DisableFreeConsultation] Existing procedures:`,
+          existingProcedures.map(p => ({
+            id: p.id,
+            name: p.name,
+            technologyId: p.technology?.id,
+            clinicBranchId: p.clinicBranchId,
+            isActive: p.isActive
+          }))
         );
         return;
       }
+      
+      console.log(
+        `[DisableFreeConsultation] Found free consultation procedure ${freeConsultation.id}, deactivating...`
+      );
 
       // Deactivate the consultation procedure
       await this.getProcedureService().deactivateProcedure(freeConsultation.id);

package/src/validations/patient/medical-info.schema.ts

@@ -63,7 +63,8 @@ export const contraindicationSchema = z.object({
   isActive: z.boolean(),
 });
 
-export const medicationSchema = z.object({
+// Base medication schema without refinement (for update operations that need .partial())
+const baseMedicationSchema = z.object({
   name: z.string().min(1),
   dosage: z.string().min(1),
   frequency: z.string().min(1),
@@ -72,6 +73,33 @@ export const medicationSchema = z.object({
   prescribedBy: z.string().optional().nullable(),
 });
 
+// Medication schema with date validation refinement
+export const medicationSchema = baseMedicationSchema.refine(
+  (data) => {
+    // If either date is not provided, skip validation (both are optional)
+    // However, if endDate is provided, startDate must also be provided
+    if (!data.endDate) {
+      return true;
+    }
+    
+    // If endDate exists but startDate doesn't, this is invalid
+    if (!data.startDate) {
+      return false;
+    }
+    
+    // Both dates must be Timestamp objects with toDate method
+    const startDate = data.startDate.toDate();
+    const endDate = data.endDate.toDate();
+    
+    // End date must be >= start date
+    return endDate >= startDate;
+  },
+  {
+    message: "End date requires a start date and must be equal to or after start date",
+    path: ["endDate"], // This will attach the error to the endDate field
+  }
+);
+
 export const patientMedicalInfoSchema = z.object({
   patientId: z.string(),
   vitalStats: vitalStatsSchema,
@@ -120,6 +148,30 @@ export const updateContraindicationSchema = contraindicationSchema
   });
 
 export const addMedicationSchema = medicationSchema;
-export const updateMedicationSchema = medicationSchema.partial().extend({
+export const updateMedicationSchema = baseMedicationSchema.partial().extend({
   medicationIndex: z.number().min(0),
-});
+}).refine(
+  (data) => {
+    // If either date is not provided, skip validation (both are optional)
+    // However, if endDate is provided, startDate must also be provided
+    if (!data.endDate) {
+      return true;
+    }
+    
+    // If endDate exists but startDate doesn't, this is invalid
+    if (!data.startDate) {
+      return false;
+    }
+    
+    // Both dates must be Timestamp objects with toDate method
+    const startDate = data.startDate.toDate();
+    const endDate = data.endDate.toDate();
+    
+    // End date must be >= start date
+    return endDate >= startDate;
+  },
+  {
+    message: "End date requires a start date and must be equal to or after start date",
+    path: ["endDate"], // This will attach the error to the endDate field
+  }
+);