@blackcode_sa/metaestetics-api 1.7.12 → 1.7.13

package/dist/admin/index.mjs

@@ -148,9 +148,9 @@ var Logger = class {
 
 // src/admin/notifications/notifications.admin.ts
 var NotificationsAdmin = class {
-  constructor(firestore13) {
+  constructor(firestore15) {
     this.expo = new Expo();
-    this.db = firestore13 || admin.firestore();
+    this.db = firestore15 || admin.firestore();
   }
   /**
    * Dohvata notifikaciju po ID-u
@@ -869,8 +869,8 @@ var ClinicAggregationService = class {
    * Constructor for ClinicAggregationService.
    * @param firestore Optional Firestore instance. If not provided, it uses the default admin SDK instance.
    */
-  constructor(firestore13) {
-    this.db = firestore13 || admin3.firestore();
+  constructor(firestore15) {
+    this.db = firestore15 || admin3.firestore();
   }
   /**
    * Adds clinic information to a clinic group when a new clinic is created
@@ -1344,8 +1344,8 @@ var ClinicAggregationService = class {
 import * as admin4 from "firebase-admin";
 var CALENDAR_SUBCOLLECTION_ID2 = "calendar";
 var PractitionerAggregationService = class {
-  constructor(firestore13) {
-    this.db = firestore13 || admin4.firestore();
+  constructor(firestore15) {
+    this.db = firestore15 || admin4.firestore();
   }
   /**
    * Adds practitioner information to a clinic when a new practitioner is created
@@ -1680,8 +1680,8 @@ var PractitionerAggregationService = class {
 import * as admin5 from "firebase-admin";
 var CALENDAR_SUBCOLLECTION_ID3 = "calendar";
 var ProcedureAggregationService = class {
-  constructor(firestore13) {
-    this.db = firestore13 || admin5.firestore();
+  constructor(firestore15) {
+    this.db = firestore15 || admin5.firestore();
   }
   /**
    * Adds procedure information to a practitioner when a new procedure is created
@@ -2065,8 +2065,8 @@ var ProcedureAggregationService = class {
 import * as admin6 from "firebase-admin";
 var CALENDAR_SUBCOLLECTION_ID4 = "calendar";
 var PatientAggregationService = class {
-  constructor(firestore13) {
-    this.db = firestore13 || admin6.firestore();
+  constructor(firestore15) {
+    this.db = firestore15 || admin6.firestore();
   }
   // --- Methods for Patient Creation --- >
   // No specific aggregations defined for patient creation in the plan.
@@ -2198,8 +2198,8 @@ var PATIENT_REQUIREMENTS_SUBCOLLECTION_NAME = "patientRequirements";
 // src/admin/requirements/patient-requirements.admin.service.ts
 import * as admin7 from "firebase-admin";
 var PatientRequirementsAdminService = class {
-  constructor(firestore13) {
-    this.db = firestore13 || admin7.firestore();
+  constructor(firestore15) {
+    this.db = firestore15 || admin7.firestore();
     this.notificationsAdmin = new NotificationsAdmin(this.db);
   }
   /**
@@ -2527,8 +2527,8 @@ var PatientRequirementsAdminService = class {
 // src/admin/calendar/calendar.admin.service.ts
 import * as admin8 from "firebase-admin";
 var CalendarAdminService = class {
-  constructor(firestore13) {
-    this.db = firestore13 || admin8.firestore();
+  constructor(firestore15) {
+    this.db = firestore15 || admin8.firestore();
     Logger.info("[CalendarAdminService] Initialized.");
   }
   /**
@@ -2811,9 +2811,9 @@ var BaseMailingService = class {
    * @param firestore Firestore instance provided by the caller
    * @param mailgunClient Mailgun client instance (mailgun.js v10+) provided by the caller
    */
-  constructor(firestore13, mailgunClient) {
+  constructor(firestore15, mailgunClient) {
     var _a;
-    this.db = firestore13;
+    this.db = firestore15;
     this.mailgunClient = mailgunClient;
     if (!this.db) {
       Logger.error("[BaseMailingService] No Firestore instance provided");
@@ -2957,8 +2957,8 @@ var BaseMailingService = class {
 var patientAppointmentConfirmedTemplate = "<h1>Appointment Confirmed</h1><p>Dear {{patientName}},</p><p>Your appointment for {{procedureName}} on {{appointmentDate}} at {{appointmentTime}} with {{practitionerName}} at {{clinicName}} has been confirmed.</p><p>Thank you!</p>";
 var clinicAppointmentRequestedTemplate = "<h1>New Appointment Request</h1><p>Hello {{clinicName}} Admin,</p><p>A new appointment for {{procedureName}} has been requested by {{patientName}} for {{appointmentDate}} at {{appointmentTime}} with {{practitionerName}}.</p><p>Please review and confirm in the admin panel.</p>";
 var AppointmentMailingService = class extends BaseMailingService {
-  constructor(firestore13, mailgunClient) {
-    super(firestore13, mailgunClient);
+  constructor(firestore15, mailgunClient) {
+    super(firestore15, mailgunClient);
     this.DEFAULT_MAILGUN_DOMAIN = "mg.metaesthetics.net";
     Logger.info("[AppointmentMailingService] Initialized.");
   }
@@ -3107,8 +3107,8 @@ var AppointmentAggregationService = class {
    * @param mailgunClient - An initialized Mailgun client instance.
    * @param firestore Optional Firestore instance. If not provided, it uses the default admin SDK instance.
    */
-  constructor(mailgunClient, firestore13) {
-    this.db = firestore13 || admin10.firestore();
+  constructor(mailgunClient, firestore15) {
+    this.db = firestore15 || admin10.firestore();
     this.appointmentMailingService = new AppointmentMailingService(
       this.db,
       mailgunClient
@@ -4357,6 +4357,658 @@ var AppointmentAggregationService = class {
   }
 };
 
+// src/admin/aggregation/forms/filled-forms.aggregation.service.ts
+import * as admin11 from "firebase-admin";
+var FilledFormsAggregationService = class {
+  /**
+   * Constructor for FilledFormsAggregationService.
+   * @param firestore Optional Firestore instance. If not provided, it uses the default admin SDK instance.
+   */
+  constructor(firestore15) {
+    this.db = firestore15 || admin11.firestore();
+    Logger.info("[FilledFormsAggregationService] Initialized");
+  }
+  /**
+   * Handles side effects when a filled form is created or updated.
+   * This function would typically be called by a Firestore onCreate or onUpdate trigger.
+   * @param filledDocument The filled document that was created or updated.
+   * @returns {Promise<void>}
+   */
+  async handleFilledFormCreateOrUpdate(filledDocument) {
+    Logger.info(
+      `[FilledFormsAggregationService] Handling CREATE/UPDATE for filled form: ${filledDocument.id}, appointment: ${filledDocument.appointmentId}`
+    );
+    try {
+      const appointmentRef = this.db.collection(APPOINTMENTS_COLLECTION).doc(filledDocument.appointmentId);
+      const appointmentDoc = await appointmentRef.get();
+      if (!appointmentDoc.exists) {
+        Logger.error(
+          `[FilledFormsAggregationService] Appointment ${filledDocument.appointmentId} not found.`
+        );
+        return;
+      }
+      const appointment = appointmentDoc.data();
+      const formSubcollection = filledDocument.isUserForm ? USER_FORMS_SUBCOLLECTION : DOCTOR_FORMS_SUBCOLLECTION;
+      const linkedFormInfo = {
+        formId: filledDocument.id,
+        templateId: filledDocument.templateId,
+        templateVersion: filledDocument.templateVersion,
+        title: filledDocument.isUserForm ? "User Form" : "Doctor Form",
+        // Default title if not available
+        isUserForm: filledDocument.isUserForm,
+        isRequired: filledDocument.isRequired,
+        status: filledDocument.status,
+        path: `${APPOINTMENTS_COLLECTION}/${filledDocument.appointmentId}/${formSubcollection}/${filledDocument.id}`
+      };
+      if (filledDocument.updatedAt) {
+        linkedFormInfo.submittedAt = admin11.firestore.Timestamp.fromMillis(
+          filledDocument.updatedAt
+        );
+      }
+      if (filledDocument.status === "completed" /* COMPLETED */ || filledDocument.status === "signed" /* SIGNED */) {
+        linkedFormInfo.completedAt = admin11.firestore.Timestamp.fromMillis(
+          filledDocument.updatedAt
+        );
+      }
+      let updateData = {};
+      let existingFormIndex = -1;
+      if (appointment.linkedForms && appointment.linkedForms.length > 0) {
+        existingFormIndex = appointment.linkedForms.findIndex(
+          (form) => form.formId === filledDocument.id
+        );
+      }
+      if (existingFormIndex >= 0 && appointment.linkedForms) {
+        updateData = {
+          linkedForms: admin11.firestore.FieldValue.arrayRemove(
+            appointment.linkedForms[existingFormIndex]
+          ),
+          updatedAt: admin11.firestore.FieldValue.serverTimestamp()
+        };
+        await appointmentRef.update(updateData);
+        updateData = {
+          linkedForms: admin11.firestore.FieldValue.arrayUnion(linkedFormInfo),
+          updatedAt: admin11.firestore.FieldValue.serverTimestamp()
+        };
+      } else {
+        updateData = {
+          linkedForms: appointment.linkedForms ? admin11.firestore.FieldValue.arrayUnion(linkedFormInfo) : [linkedFormInfo],
+          // If linkedForms doesn't exist, create a new array
+          linkedFormIds: appointment.linkedFormIds ? admin11.firestore.FieldValue.arrayUnion(filledDocument.id) : [filledDocument.id],
+          // If linkedFormIds doesn't exist, create a new array
+          updatedAt: admin11.firestore.FieldValue.serverTimestamp()
+        };
+      }
+      if (filledDocument.isUserForm && filledDocument.isRequired && (filledDocument.status === "completed" /* COMPLETED */ || filledDocument.status === "signed" /* SIGNED */)) {
+        if (appointment.pendingUserFormsIds && appointment.pendingUserFormsIds.includes(filledDocument.id)) {
+          updateData.pendingUserFormsIds = admin11.firestore.FieldValue.arrayRemove(filledDocument.id);
+          Logger.info(
+            `[FilledFormsAggregationService] Removing form ${filledDocument.id} from pendingUserFormsIds`
+          );
+        }
+      }
+      await appointmentRef.update(updateData);
+      Logger.info(
+        `[FilledFormsAggregationService] Successfully updated appointment ${filledDocument.appointmentId} with form info for ${filledDocument.id}`
+      );
+    } catch (error) {
+      Logger.error(
+        `[FilledFormsAggregationService] Error updating appointment for filled form ${filledDocument.id}:`,
+        error
+      );
+      throw error;
+    }
+  }
+  /**
+   * Handles side effects when a filled form is deleted.
+   * This function would typically be called by a Firestore onDelete trigger.
+   * @param filledDocument The filled document that was deleted.
+   * @returns {Promise<void>}
+   */
+  async handleFilledFormDelete(filledDocument) {
+    Logger.info(
+      `[FilledFormsAggregationService] Handling DELETE for filled form: ${filledDocument.id}, appointment: ${filledDocument.appointmentId}`
+    );
+    try {
+      const appointmentRef = this.db.collection(APPOINTMENTS_COLLECTION).doc(filledDocument.appointmentId);
+      const appointmentDoc = await appointmentRef.get();
+      if (!appointmentDoc.exists) {
+        Logger.error(
+          `[FilledFormsAggregationService] Appointment ${filledDocument.appointmentId} not found.`
+        );
+        return;
+      }
+      const appointment = appointmentDoc.data();
+      let updateData = {};
+      if (appointment.linkedForms && appointment.linkedForms.length > 0) {
+        const formToRemove = appointment.linkedForms.find(
+          (form) => form.formId === filledDocument.id
+        );
+        if (formToRemove) {
+          updateData.linkedForms = admin11.firestore.FieldValue.arrayRemove(formToRemove);
+        }
+      }
+      if (appointment.linkedFormIds && appointment.linkedFormIds.includes(filledDocument.id)) {
+        updateData.linkedFormIds = admin11.firestore.FieldValue.arrayRemove(
+          filledDocument.id
+        );
+      }
+      if (filledDocument.isUserForm && filledDocument.isRequired) {
+        if (filledDocument.status !== "completed" /* COMPLETED */ && filledDocument.status !== "signed" /* SIGNED */) {
+          if (!appointment.pendingUserFormsIds || !appointment.pendingUserFormsIds.includes(filledDocument.id)) {
+            updateData.pendingUserFormsIds = appointment.pendingUserFormsIds ? admin11.firestore.FieldValue.arrayUnion(filledDocument.id) : [filledDocument.id];
+          }
+        }
+      }
+      if (Object.keys(updateData).length > 0) {
+        updateData.updatedAt = admin11.firestore.FieldValue.serverTimestamp();
+        await appointmentRef.update(updateData);
+        Logger.info(
+          `[FilledFormsAggregationService] Successfully updated appointment ${filledDocument.appointmentId} after form deletion`
+        );
+      } else {
+        Logger.info(
+          `[FilledFormsAggregationService] No updates needed for appointment ${filledDocument.appointmentId}`
+        );
+      }
+    } catch (error) {
+      Logger.error(
+        `[FilledFormsAggregationService] Error updating appointment after form deletion for ${filledDocument.id}:`,
+        error
+      );
+      throw error;
+    }
+  }
+  /**
+   * Updates the appointment's pendingUserFormsIds for a new required user form.
+   * This should be called when a required user form is first created.
+   * @param filledDocument The newly created filled document.
+   * @returns {Promise<void>}
+   */
+  async handleRequiredUserFormCreate(filledDocument) {
+    if (!filledDocument.isUserForm || !filledDocument.isRequired) {
+      return;
+    }
+    Logger.info(
+      `[FilledFormsAggregationService] Handling new required user form creation: ${filledDocument.id}`
+    );
+    try {
+      const appointmentRef = this.db.collection(APPOINTMENTS_COLLECTION).doc(filledDocument.appointmentId);
+      if (filledDocument.status === "completed" /* COMPLETED */ || filledDocument.status === "signed" /* SIGNED */) {
+        Logger.info(
+          `[FilledFormsAggregationService] Form ${filledDocument.id} is already completed/signed, not adding to pendingUserFormsIds`
+        );
+        return;
+      }
+      await appointmentRef.update({
+        pendingUserFormsIds: admin11.firestore.FieldValue.arrayUnion(
+          filledDocument.id
+        ),
+        updatedAt: admin11.firestore.FieldValue.serverTimestamp()
+      });
+      Logger.info(
+        `[FilledFormsAggregationService] Successfully added form ${filledDocument.id} to pendingUserFormsIds for appointment ${filledDocument.appointmentId}`
+      );
+    } catch (error) {
+      Logger.error(
+        `[FilledFormsAggregationService] Error handling required user form creation for ${filledDocument.id}:`,
+        error
+      );
+      throw error;
+    }
+  }
+};
+
+// src/admin/aggregation/reviews/reviews.aggregation.service.ts
+import * as admin12 from "firebase-admin";
+
+// src/types/reviews/index.ts
+var REVIEWS_COLLECTION = "reviews";
+
+// src/admin/aggregation/reviews/reviews.aggregation.service.ts
+var ReviewsAggregationService = class {
+  /**
+   * Constructor for ReviewsAggregationService.
+   * @param firestore Optional Firestore instance. If not provided, it uses the default admin SDK instance.
+   */
+  constructor(firestore15) {
+    this.db = firestore15 || admin12.firestore();
+  }
+  /**
+   * Process a newly created review and update all related entities
+   * @param review The newly created review
+   * @returns Promise resolving when all updates are complete
+   */
+  async processNewReview(review) {
+    console.log(
+      `[ReviewsAggregationService] Processing new review: ${review.id}`
+    );
+    const updatePromises = [];
+    if (review.clinicReview) {
+      updatePromises.push(
+        this.updateClinicReviewInfo(review.clinicReview.clinicId)
+      );
+    }
+    if (review.practitionerReview) {
+      updatePromises.push(
+        this.updatePractitionerReviewInfo(
+          review.practitionerReview.practitionerId
+        )
+      );
+    }
+    if (review.procedureReview) {
+      updatePromises.push(
+        this.updateProcedureReviewInfo(review.procedureReview.procedureId)
+      );
+    }
+    await Promise.all(updatePromises);
+    console.log(
+      `[ReviewsAggregationService] Successfully processed review: ${review.id}`
+    );
+  }
+  /**
+   * Process a deleted review and update all related entities
+   * @param review The deleted review
+   * @returns Promise resolving when all updates are complete
+   */
+  async processDeletedReview(review) {
+    console.log(
+      `[ReviewsAggregationService] Processing deleted review: ${review.id}`
+    );
+    const updatePromises = [];
+    if (review.clinicReview) {
+      updatePromises.push(
+        this.updateClinicReviewInfo(
+          review.clinicReview.clinicId,
+          review.clinicReview,
+          true
+        )
+      );
+    }
+    if (review.practitionerReview) {
+      updatePromises.push(
+        this.updatePractitionerReviewInfo(
+          review.practitionerReview.practitionerId,
+          review.practitionerReview,
+          true
+        )
+      );
+    }
+    if (review.procedureReview) {
+      updatePromises.push(
+        this.updateProcedureReviewInfo(
+          review.procedureReview.procedureId,
+          review.procedureReview,
+          true
+        )
+      );
+    }
+    await Promise.all(updatePromises);
+    console.log(
+      `[ReviewsAggregationService] Successfully processed deleted review: ${review.id}`
+    );
+  }
+  /**
+   * Updates the review info for a clinic
+   * @param clinicId The ID of the clinic to update
+   * @param removedReview Optional review being removed
+   * @param isRemoval Whether this update is for a review removal
+   * @returns The updated clinic review info
+   */
+  async updateClinicReviewInfo(clinicId, removedReview, isRemoval = false) {
+    console.log(
+      `[ReviewsAggregationService] Updating review info for clinic: ${clinicId}`
+    );
+    const clinicDoc = await this.db.collection(CLINICS_COLLECTION).doc(clinicId).get();
+    if (!clinicDoc.exists) {
+      console.error(
+        `[ReviewsAggregationService] Clinic with ID ${clinicId} not found`
+      );
+      throw new Error(`Clinic with ID ${clinicId} not found`);
+    }
+    const clinicData = clinicDoc.data();
+    const currentReviewInfo = (clinicData == null ? void 0 : clinicData.reviewInfo) || {
+      totalReviews: 0,
+      averageRating: 0,
+      cleanliness: 0,
+      facilities: 0,
+      staffFriendliness: 0,
+      waitingTime: 0,
+      accessibility: 0,
+      recommendationPercentage: 0
+    };
+    const reviewsQuery = await this.db.collection(REVIEWS_COLLECTION).where("clinicReview.clinicId", "==", clinicId).get();
+    if (isRemoval && reviewsQuery.size <= 1 || reviewsQuery.empty) {
+      const updatedReviewInfo2 = {
+        totalReviews: 0,
+        averageRating: 0,
+        cleanliness: 0,
+        facilities: 0,
+        staffFriendliness: 0,
+        waitingTime: 0,
+        accessibility: 0,
+        recommendationPercentage: 0
+      };
+      await this.db.collection(CLINICS_COLLECTION).doc(clinicId).update({
+        reviewInfo: updatedReviewInfo2,
+        updatedAt: admin12.firestore.FieldValue.serverTimestamp()
+      });
+      console.log(
+        `[ReviewsAggregationService] Reset review info for clinic: ${clinicId}`
+      );
+      return updatedReviewInfo2;
+    }
+    const reviews = reviewsQuery.docs.map((doc) => doc.data());
+    const clinicReviews = reviews.map((review) => review.clinicReview).filter((review) => review !== void 0);
+    let totalRating = 0;
+    let totalCleanliness = 0;
+    let totalFacilities = 0;
+    let totalStaffFriendliness = 0;
+    let totalWaitingTime = 0;
+    let totalAccessibility = 0;
+    let totalRecommendations = 0;
+    clinicReviews.forEach((review) => {
+      totalRating += review.overallRating;
+      totalCleanliness += review.cleanliness;
+      totalFacilities += review.facilities;
+      totalStaffFriendliness += review.staffFriendliness;
+      totalWaitingTime += review.waitingTime;
+      totalAccessibility += review.accessibility;
+      if (review.wouldRecommend) totalRecommendations++;
+    });
+    const count = clinicReviews.length;
+    const roundToOneDecimal = (value) => Math.round(value / count * 10) / 10;
+    const updatedReviewInfo = {
+      totalReviews: count,
+      averageRating: roundToOneDecimal(totalRating),
+      cleanliness: roundToOneDecimal(totalCleanliness),
+      facilities: roundToOneDecimal(totalFacilities),
+      staffFriendliness: roundToOneDecimal(totalStaffFriendliness),
+      waitingTime: roundToOneDecimal(totalWaitingTime),
+      accessibility: roundToOneDecimal(totalAccessibility),
+      recommendationPercentage: Math.round(totalRecommendations / count * 1e3) / 10
+    };
+    await this.db.collection(CLINICS_COLLECTION).doc(clinicId).update({
+      reviewInfo: updatedReviewInfo,
+      updatedAt: admin12.firestore.FieldValue.serverTimestamp()
+    });
+    console.log(
+      `[ReviewsAggregationService] Updated review info for clinic: ${clinicId}`
+    );
+    return updatedReviewInfo;
+  }
+  /**
+   * Updates the review info for a practitioner
+   * @param practitionerId The ID of the practitioner to update
+   * @param removedReview Optional review being removed
+   * @param isRemoval Whether this update is for a review removal
+   * @returns The updated practitioner review info
+   */
+  async updatePractitionerReviewInfo(practitionerId, removedReview, isRemoval = false) {
+    console.log(
+      `[ReviewsAggregationService] Updating review info for practitioner: ${practitionerId}`
+    );
+    const practitionerDoc = await this.db.collection(PRACTITIONERS_COLLECTION).doc(practitionerId).get();
+    if (!practitionerDoc.exists) {
+      console.error(
+        `[ReviewsAggregationService] Practitioner with ID ${practitionerId} not found`
+      );
+      throw new Error(`Practitioner with ID ${practitionerId} not found`);
+    }
+    const practitionerData = practitionerDoc.data();
+    const currentReviewInfo = (practitionerData == null ? void 0 : practitionerData.reviewInfo) || {
+      totalReviews: 0,
+      averageRating: 0,
+      knowledgeAndExpertise: 0,
+      communicationSkills: 0,
+      bedSideManner: 0,
+      thoroughness: 0,
+      trustworthiness: 0,
+      recommendationPercentage: 0
+    };
+    const reviewsQuery = await this.db.collection(REVIEWS_COLLECTION).where("practitionerReview.practitionerId", "==", practitionerId).get();
+    if (isRemoval && reviewsQuery.size <= 1 || reviewsQuery.empty) {
+      const updatedReviewInfo2 = {
+        totalReviews: 0,
+        averageRating: 0,
+        knowledgeAndExpertise: 0,
+        communicationSkills: 0,
+        bedSideManner: 0,
+        thoroughness: 0,
+        trustworthiness: 0,
+        recommendationPercentage: 0
+      };
+      await this.db.collection(PRACTITIONERS_COLLECTION).doc(practitionerId).update({
+        reviewInfo: updatedReviewInfo2,
+        updatedAt: admin12.firestore.FieldValue.serverTimestamp()
+      });
+      await this.updateDoctorInfoInProcedures(practitionerId, 0);
+      console.log(
+        `[ReviewsAggregationService] Reset review info for practitioner: ${practitionerId}`
+      );
+      return updatedReviewInfo2;
+    }
+    const reviews = reviewsQuery.docs.map((doc) => doc.data());
+    const practitionerReviews = reviews.map((review) => review.practitionerReview).filter((review) => review !== void 0);
+    let totalRating = 0;
+    let totalKnowledgeAndExpertise = 0;
+    let totalCommunicationSkills = 0;
+    let totalBedSideManner = 0;
+    let totalThoroughness = 0;
+    let totalTrustworthiness = 0;
+    let totalRecommendations = 0;
+    practitionerReviews.forEach((review) => {
+      totalRating += review.overallRating;
+      totalKnowledgeAndExpertise += review.knowledgeAndExpertise;
+      totalCommunicationSkills += review.communicationSkills;
+      totalBedSideManner += review.bedSideManner;
+      totalThoroughness += review.thoroughness;
+      totalTrustworthiness += review.trustworthiness;
+      if (review.wouldRecommend) totalRecommendations++;
+    });
+    const count = practitionerReviews.length;
+    const roundToOneDecimal = (value) => Math.round(value / count * 10) / 10;
+    const updatedReviewInfo = {
+      totalReviews: count,
+      averageRating: roundToOneDecimal(totalRating),
+      knowledgeAndExpertise: roundToOneDecimal(totalKnowledgeAndExpertise),
+      communicationSkills: roundToOneDecimal(totalCommunicationSkills),
+      bedSideManner: roundToOneDecimal(totalBedSideManner),
+      thoroughness: roundToOneDecimal(totalThoroughness),
+      trustworthiness: roundToOneDecimal(totalTrustworthiness),
+      recommendationPercentage: Math.round(totalRecommendations / count * 1e3) / 10
+    };
+    await this.db.collection(PRACTITIONERS_COLLECTION).doc(practitionerId).update({
+      reviewInfo: updatedReviewInfo,
+      updatedAt: admin12.firestore.FieldValue.serverTimestamp()
+    });
+    await this.updateDoctorInfoInProcedures(
+      practitionerId,
+      updatedReviewInfo.averageRating
+    );
+    console.log(
+      `[ReviewsAggregationService] Updated review info for practitioner: ${practitionerId}`
+    );
+    return updatedReviewInfo;
+  }
+  /**
+   * Updates the review info for a procedure
+   * @param procedureId The ID of the procedure to update
+   * @param removedReview Optional review being removed
+   * @param isRemoval Whether this update is for a review removal
+   * @returns The updated procedure review info
+   */
+  async updateProcedureReviewInfo(procedureId, removedReview, isRemoval = false) {
+    console.log(
+      `[ReviewsAggregationService] Updating review info for procedure: ${procedureId}`
+    );
+    const procedureDoc = await this.db.collection(PROCEDURES_COLLECTION).doc(procedureId).get();
+    if (!procedureDoc.exists) {
+      console.error(
+        `[ReviewsAggregationService] Procedure with ID ${procedureId} not found`
+      );
+      throw new Error(`Procedure with ID ${procedureId} not found`);
+    }
+    const procedureData = procedureDoc.data();
+    const currentReviewInfo = (procedureData == null ? void 0 : procedureData.reviewInfo) || {
+      totalReviews: 0,
+      averageRating: 0,
+      effectivenessOfTreatment: 0,
+      outcomeExplanation: 0,
+      painManagement: 0,
+      followUpCare: 0,
+      valueForMoney: 0,
+      recommendationPercentage: 0
+    };
+    const reviewsQuery = await this.db.collection(REVIEWS_COLLECTION).where("procedureReview.procedureId", "==", procedureId).get();
+    if (isRemoval && reviewsQuery.size <= 1 || reviewsQuery.empty) {
+      const updatedReviewInfo2 = {
+        totalReviews: 0,
+        averageRating: 0,
+        effectivenessOfTreatment: 0,
+        outcomeExplanation: 0,
+        painManagement: 0,
+        followUpCare: 0,
+        valueForMoney: 0,
+        recommendationPercentage: 0
+      };
+      await this.db.collection(PROCEDURES_COLLECTION).doc(procedureId).update({
+        reviewInfo: updatedReviewInfo2,
+        updatedAt: admin12.firestore.FieldValue.serverTimestamp()
+      });
+      console.log(
+        `[ReviewsAggregationService] Reset review info for procedure: ${procedureId}`
+      );
+      return updatedReviewInfo2;
+    }
+    const reviews = reviewsQuery.docs.map((doc) => doc.data());
+    const procedureReviews = reviews.map((review) => review.procedureReview).filter((review) => review !== void 0);
+    let totalRating = 0;
+    let totalEffectivenessOfTreatment = 0;
+    let totalOutcomeExplanation = 0;
+    let totalPainManagement = 0;
+    let totalFollowUpCare = 0;
+    let totalValueForMoney = 0;
+    let totalRecommendations = 0;
+    procedureReviews.forEach((review) => {
+      totalRating += review.overallRating;
+      totalEffectivenessOfTreatment += review.effectivenessOfTreatment;
+      totalOutcomeExplanation += review.outcomeExplanation;
+      totalPainManagement += review.painManagement;
+      totalFollowUpCare += review.followUpCare;
+      totalValueForMoney += review.valueForMoney;
+      if (review.wouldRecommend) totalRecommendations++;
+    });
+    const count = procedureReviews.length;
+    const roundToOneDecimal = (value) => Math.round(value / count * 10) / 10;
+    const updatedReviewInfo = {
+      totalReviews: count,
+      averageRating: roundToOneDecimal(totalRating),
+      effectivenessOfTreatment: roundToOneDecimal(
+        totalEffectivenessOfTreatment
+      ),
+      outcomeExplanation: roundToOneDecimal(totalOutcomeExplanation),
+      painManagement: roundToOneDecimal(totalPainManagement),
+      followUpCare: roundToOneDecimal(totalFollowUpCare),
+      valueForMoney: roundToOneDecimal(totalValueForMoney),
+      recommendationPercentage: Math.round(totalRecommendations / count * 1e3) / 10
+    };
+    await this.db.collection(PROCEDURES_COLLECTION).doc(procedureId).update({
+      reviewInfo: updatedReviewInfo,
+      updatedAt: admin12.firestore.FieldValue.serverTimestamp()
+    });
+    console.log(
+      `[ReviewsAggregationService] Updated review info for procedure: ${procedureId}`
+    );
+    return updatedReviewInfo;
+  }
+  /**
+   * Updates doctorInfo rating in all procedures for a practitioner
+   * @param practitionerId The ID of the practitioner
+   * @param rating The new rating to set
+   */
+  async updateDoctorInfoInProcedures(practitionerId, rating) {
+    console.log(
+      `[ReviewsAggregationService] Updating doctor info in procedures for practitioner: ${practitionerId}`
+    );
+    const proceduresQuery = await this.db.collection(PROCEDURES_COLLECTION).where("practitionerId", "==", practitionerId).get();
+    if (proceduresQuery.empty) {
+      console.log(
+        `[ReviewsAggregationService] No procedures found for practitioner: ${practitionerId}`
+      );
+      return;
+    }
+    const batch = this.db.batch();
+    proceduresQuery.docs.forEach((docSnapshot) => {
+      const procedureRef = this.db.collection(PROCEDURES_COLLECTION).doc(docSnapshot.id);
+      batch.update(procedureRef, {
+        "doctorInfo.rating": rating,
+        updatedAt: admin12.firestore.FieldValue.serverTimestamp()
+      });
+    });
+    await batch.commit();
+    console.log(
+      `[ReviewsAggregationService] Updated doctor info in ${proceduresQuery.size} procedures for practitioner: ${practitionerId}`
+    );
+  }
+  /**
+   * Verifies a review as checked by admin/staff
+   * @param reviewId The ID of the review to verify
+   */
+  async verifyReview(reviewId) {
+    console.log(`[ReviewsAggregationService] Verifying review: ${reviewId}`);
+    const reviewDoc = await this.db.collection(REVIEWS_COLLECTION).doc(reviewId).get();
+    if (!reviewDoc.exists) {
+      console.error(
+        `[ReviewsAggregationService] Review with ID ${reviewId} not found`
+      );
+      throw new Error(`Review with ID ${reviewId} not found`);
+    }
+    const review = reviewDoc.data();
+    const batch = this.db.batch();
+    const reviewRef = this.db.collection(REVIEWS_COLLECTION).doc(reviewId);
+    if (review.clinicReview) {
+      review.clinicReview.isVerified = true;
+    }
+    if (review.practitionerReview) {
+      review.practitionerReview.isVerified = true;
+    }
+    if (review.procedureReview) {
+      review.procedureReview.isVerified = true;
+    }
+    batch.update(reviewRef, {
+      clinicReview: review.clinicReview,
+      practitionerReview: review.practitionerReview,
+      procedureReview: review.procedureReview,
+      updatedAt: admin12.firestore.FieldValue.serverTimestamp()
+    });
+    await batch.commit();
+    console.log(
+      `[ReviewsAggregationService] Successfully verified review: ${reviewId}`
+    );
+  }
+  /**
+   * Calculate the average of all reviews for an entity
+   * @param entityId The entity ID
+   * @param entityType The type of entity ('clinic', 'practitioner', or 'procedure')
+   * @returns Promise that resolves to the calculated review info
+   */
+  async calculateEntityReviewInfo(entityId, entityType) {
+    console.log(
+      `[ReviewsAggregationService] Calculating review info for ${entityType}: ${entityId}`
+    );
+    switch (entityType) {
+      case "clinic":
+        return this.updateClinicReviewInfo(entityId);
+      case "practitioner":
+        return this.updatePractitionerReviewInfo(entityId);
+      case "procedure":
+        return this.updateProcedureReviewInfo(entityId);
+      default:
+        throw new Error(`Invalid entity type: ${entityType}`);
+    }
+  }
+};
+
 // src/admin/mailing/practitionerInvite/templates/invitation.template.ts
 var practitionerInvitationTemplate = `
 <!DOCTYPE html>
@@ -4464,8 +5116,8 @@ var PractitionerInviteMailingService = class extends BaseMailingService {
    * @param firestore Firestore instance provided by the caller
    * @param mailgunClient Mailgun client instance (mailgun.js v10+) provided by the caller
    */
-  constructor(firestore13, mailgunClient) {
-    super(firestore13, mailgunClient);
+  constructor(firestore15, mailgunClient) {
+    super(firestore15, mailgunClient);
     this.DEFAULT_REGISTRATION_URL = "https://metaesthetics.net/register";
     this.DEFAULT_SUBJECT = "You've Been Invited to Join as a Practitioner";
     this.DEFAULT_MAILGUN_DOMAIN = "mg.metaesthetics.net";
@@ -4703,7 +5355,7 @@ var PractitionerInviteMailingService = class extends BaseMailingService {
 };
 
 // src/admin/booking/booking.admin.ts
-import * as admin12 from "firebase-admin";
+import * as admin14 from "firebase-admin";
 
 // src/admin/booking/booking.calculator.ts
 import { Timestamp } from "firebase/firestore";
@@ -5137,10 +5789,10 @@ var BookingAvailabilityCalculator = class {
 BookingAvailabilityCalculator.DEFAULT_INTERVAL_MINUTES = 15;
 
 // src/admin/documentation-templates/document-manager.admin.ts
-import * as admin11 from "firebase-admin";
+import * as admin13 from "firebase-admin";
 var DocumentManagerAdminService = class {
-  constructor(firestore13) {
-    this.db = firestore13;
+  constructor(firestore15) {
+    this.db = firestore15;
   }
   /**
    * Adds operations to a Firestore batch to initialize all linked forms for a new appointment
@@ -5243,7 +5895,7 @@ var DocumentManagerAdminService = class {
       };
     }
     const templateIds = technologyTemplates.map((t) => t.templateId);
-    const templatesSnapshot = await this.db.collection(DOCUMENTATION_TEMPLATES_COLLECTION).where(admin11.firestore.FieldPath.documentId(), "in", templateIds).get();
+    const templatesSnapshot = await this.db.collection(DOCUMENTATION_TEMPLATES_COLLECTION).where(admin13.firestore.FieldPath.documentId(), "in", templateIds).get();
     const templatesMap = /* @__PURE__ */ new Map();
     templatesSnapshot.forEach((doc) => {
       templatesMap.set(doc.id, doc.data());
@@ -5309,8 +5961,8 @@ var BookingAdmin = class {
    * Creates a new BookingAdmin instance
    * @param firestore - Firestore instance provided by the caller
    */
-  constructor(firestore13) {
-    this.db = firestore13 || admin12.firestore();
+  constructor(firestore15) {
+    this.db = firestore15 || admin14.firestore();
     this.documentManagerAdmin = new DocumentManagerAdminService(this.db);
   }
   /**
@@ -5327,8 +5979,8 @@ var BookingAdmin = class {
       console.log(
         `[BookingAdmin] Getting available slots for clinic ${clinicId}, practitioner ${practitionerId}, procedure ${procedureId}`
       );
-      const start = timeframe.start instanceof Date ? admin12.firestore.Timestamp.fromDate(timeframe.start) : timeframe.start;
-      const end = timeframe.end instanceof Date ? admin12.firestore.Timestamp.fromDate(timeframe.end) : timeframe.end;
+      const start = timeframe.start instanceof Date ? admin14.firestore.Timestamp.fromDate(timeframe.start) : timeframe.start;
+      const end = timeframe.end instanceof Date ? admin14.firestore.Timestamp.fromDate(timeframe.end) : timeframe.end;
       const clinicDoc = await this.db.collection("clinics").doc(clinicId).get();
       if (!clinicDoc.exists) {
         throw new Error(`Clinic ${clinicId} not found`);
@@ -5367,7 +6019,7 @@ var BookingAdmin = class {
       const result = BookingAvailabilityCalculator.calculateSlots(request);
       return {
         availableSlots: result.availableSlots.map((slot) => ({
-          start: admin12.firestore.Timestamp.fromMillis(slot.start.toMillis())
+          start: admin14.firestore.Timestamp.fromMillis(slot.start.toMillis())
         }))
       };
     } catch (error) {
@@ -5469,8 +6121,8 @@ var BookingAdmin = class {
       `[BookingAdmin] Orchestrating appointment creation for patient ${data.patientId} by user ${authenticatedUserId}`
     );
     const batch = this.db.batch();
-    const adminTsNow = admin12.firestore.Timestamp.now();
-    const serverTimestampValue = admin12.firestore.FieldValue.serverTimestamp();
+    const adminTsNow = admin14.firestore.Timestamp.now();
+    const serverTimestampValue = admin14.firestore.FieldValue.serverTimestamp();
     try {
       if (!data.patientId || !data.procedureId || !data.appointmentStartTime || !data.appointmentEndTime) {
         return {
@@ -5567,7 +6219,7 @@ var BookingAdmin = class {
         fullName: `${(patientSensitiveData == null ? void 0 : patientSensitiveData.firstName) || ""} ${(patientSensitiveData == null ? void 0 : patientSensitiveData.lastName) || ""}`.trim() || patientProfileData.displayName,
         email: (patientSensitiveData == null ? void 0 : patientSensitiveData.email) || "",
         phone: (patientSensitiveData == null ? void 0 : patientSensitiveData.phoneNumber) || patientProfileData.phoneNumber || null,
-        dateOfBirth: (patientSensitiveData == null ? void 0 : patientSensitiveData.dateOfBirth) || patientProfileData.dateOfBirth || admin12.firestore.Timestamp.now(),
+        dateOfBirth: (patientSensitiveData == null ? void 0 : patientSensitiveData.dateOfBirth) || patientProfileData.dateOfBirth || admin14.firestore.Timestamp.now(),
         gender: (patientSensitiveData == null ? void 0 : patientSensitiveData.gender) || "other" /* OTHER */
       };
       const newAppointmentId = this.db.collection(APPOINTMENTS_COLLECTION).doc().id;
@@ -5817,6 +6469,7 @@ export {
   CalendarAdminService,
   ClinicAggregationService,
   DocumentManagerAdminService,
+  FilledFormsAggregationService,
   Logger,
   MediaType,
   NOTIFICATIONS_COLLECTION,
@@ -5833,5 +6486,6 @@ export {
   PractitionerInviteMailingService,
   PractitionerTokenStatus,
   ProcedureAggregationService,
+  ReviewsAggregationService,
   UserRole
 };