@blackcode_sa/metaestetics-api 1.12.68 → 1.12.70

package/dist/index.mjs

@@ -56,13 +56,13 @@ var AppointmentStatus = /* @__PURE__ */ ((AppointmentStatus2) => {
   AppointmentStatus2["RESCHEDULED_BY_CLINIC"] = "rescheduled_by_clinic";
   return AppointmentStatus2;
 })(AppointmentStatus || {});
-var PaymentStatus = /* @__PURE__ */ ((PaymentStatus4) => {
-  PaymentStatus4["UNPAID"] = "unpaid";
-  PaymentStatus4["PAID"] = "paid";
-  PaymentStatus4["PARTIALLY_PAID"] = "partially_paid";
-  PaymentStatus4["REFUNDED"] = "refunded";
-  PaymentStatus4["NOT_APPLICABLE"] = "not_applicable";
-  return PaymentStatus4;
+var PaymentStatus = /* @__PURE__ */ ((PaymentStatus3) => {
+  PaymentStatus3["UNPAID"] = "unpaid";
+  PaymentStatus3["PAID"] = "paid";
+  PaymentStatus3["PARTIALLY_PAID"] = "partially_paid";
+  PaymentStatus3["REFUNDED"] = "refunded";
+  PaymentStatus3["NOT_APPLICABLE"] = "not_applicable";
+  return PaymentStatus3;
 })(PaymentStatus || {});
 var MediaType = /* @__PURE__ */ ((MediaType2) => {
   MediaType2["BEFORE_PHOTO"] = "before_photo";
@@ -3329,6 +3329,7 @@ var AppointmentService = class extends BaseService {
         finalbilling: null,
         finalizationNotes: null
       };
+      const shouldUpdatePaymentStatus = finalbilling.finalPrice > 0 && appointment.paymentStatus === "not_applicable" /* NOT_APPLICABLE */;
       const updateData = {
         metadata: {
           selectedZones: currentMetadata.selectedZones,
@@ -3344,6 +3345,9 @@ var AppointmentService = class extends BaseService {
           finalbilling,
           finalizationNotes: currentMetadata.finalizationNotes
         },
+        ...shouldUpdatePaymentStatus && {
+          paymentStatus: "unpaid" /* UNPAID */
+        },
         updatedAt: serverTimestamp7()
       };
       return await this.updateAppointment(appointmentId, updateData);
@@ -3557,8 +3561,36 @@ var AppointmentService = class extends BaseService {
         showCanceled: false,
         showNoShow: false
       });
+      const now = /* @__PURE__ */ new Date();
+      const allPastAppointments = await this.getPatientAppointments(patientId, {
+        endDate: now,
+        status: [
+          "completed" /* COMPLETED */,
+          "confirmed" /* CONFIRMED */,
+          "checked_in" /* CHECKED_IN */,
+          "in_progress" /* IN_PROGRESS */
+        ]
+      });
+      const appointmentsWithRecommendations = allPastAppointments.appointments.filter(
+        (appointment) => {
+          var _a2, _b2, _c2, _d;
+          const endTime = ((_a2 = appointment.appointmentEndTime) == null ? void 0 : _a2.toMillis) ? appointment.appointmentEndTime.toMillis() : ((_b2 = appointment.appointmentEndTime) == null ? void 0 : _b2.seconds) ? appointment.appointmentEndTime.seconds * 1e3 : null;
+          if (!endTime) return false;
+          const isPastEndTime = endTime < now.getTime();
+          const hasRecommendations = (((_d = (_c2 = appointment.metadata) == null ? void 0 : _c2.recommendedProcedures) == null ? void 0 : _d.length) || 0) > 0;
+          return isPastEndTime && hasRecommendations;
+        }
+      );
+      const allAppointmentsMap = /* @__PURE__ */ new Map();
+      pastAppointments.appointments.forEach((apt) => {
+        allAppointmentsMap.set(apt.id, apt);
+      });
+      appointmentsWithRecommendations.forEach((apt) => {
+        allAppointmentsMap.set(apt.id, apt);
+      });
+      const allAppointments = Array.from(allAppointmentsMap.values());
       const recommendations = [];
-      for (const appointment of pastAppointments.appointments) {
+      for (const appointment of allAppointments) {
         if ((options == null ? void 0 : options.clinicBranchId) && appointment.clinicBranchId !== options.clinicBranchId) {
           continue;
         }
@@ -3595,9 +3627,6 @@ var AppointmentService = class extends BaseService {
         return dateB - dateA;
       });
       const limitedRecommendations = (options == null ? void 0 : options.limit) ? recommendations.slice(0, options.limit) : recommendations;
-      console.log(
-        `[APPOINTMENT_SERVICE] Found ${limitedRecommendations.length} next steps recommendations for patient ${patientId}`
-      );
       return limitedRecommendations;
     } catch (error) {
       console.error(
@@ -3885,6 +3914,7 @@ var NotificationType = /* @__PURE__ */ ((NotificationType3) => {
   NotificationType3["FORM_REMINDER"] = "formReminder";
   NotificationType3["FORM_SUBMISSION_CONFIRMATION"] = "formSubmissionConfirmation";
   NotificationType3["REVIEW_REQUEST"] = "reviewRequest";
+  NotificationType3["PROCEDURE_RECOMMENDATION"] = "procedureRecommendation";
   NotificationType3["PAYMENT_DUE"] = "paymentDue";
   NotificationType3["PAYMENT_CONFIRMATION"] = "paymentConfirmation";
   NotificationType3["PAYMENT_FAILED"] = "paymentFailed";
@@ -17739,6 +17769,10 @@ var ProcedureService = class extends BaseService {
           console.log("[PROCEDURE_SERVICE] Strategy 1: Trying nameLower search");
           const searchTerm = filters.nameSearch.trim().toLowerCase();
           const constraints = getBaseConstraints();
+          const hasNestedFilters = !!(filters.procedureTechnology || filters.procedureCategory || filters.procedureSubcategory);
+          if (hasNestedFilters) {
+            console.log("[PROCEDURE_SERVICE] Strategy 1: Has nested filters, will apply client-side after query");
+          }
           constraints.push(where31("nameLower", ">=", searchTerm));
           constraints.push(where31("nameLower", "<=", searchTerm + "\uF8FF"));
           constraints.push(orderBy18("nameLower"));
@@ -17754,9 +17788,12 @@ var ProcedureService = class extends BaseService {
           constraints.push(limit16(filters.pagination || 10));
           const q = query31(collection31(this.db, PROCEDURES_COLLECTION), ...constraints);
           const querySnapshot = await getDocs31(q);
-          const procedures = querySnapshot.docs.map(
+          let procedures = querySnapshot.docs.map(
             (doc45) => ({ ...doc45.data(), id: doc45.id })
           );
+          if (hasNestedFilters) {
+            procedures = this.applyInMemoryFilters(procedures, filters);
+          }
           const lastDoc = querySnapshot.docs.length > 0 ? querySnapshot.docs[querySnapshot.docs.length - 1] : null;
           console.log(`[PROCEDURE_SERVICE] Strategy 1 success: ${procedures.length} procedures`);
           if (procedures.length < (filters.pagination || 10)) {
@@ -17772,6 +17809,10 @@ var ProcedureService = class extends BaseService {
           console.log("[PROCEDURE_SERVICE] Strategy 2: Trying name field search");
           const searchTerm = filters.nameSearch.trim().toLowerCase();
           const constraints = getBaseConstraints();
+          const hasNestedFilters = !!(filters.procedureTechnology || filters.procedureCategory || filters.procedureSubcategory);
+          if (hasNestedFilters) {
+            console.log("[PROCEDURE_SERVICE] Strategy 2: Has nested filters, will apply client-side after query");
+          }
           constraints.push(where31("name", ">=", searchTerm));
           constraints.push(where31("name", "<=", searchTerm + "\uF8FF"));
           constraints.push(orderBy18("name"));
@@ -17787,9 +17828,12 @@ var ProcedureService = class extends BaseService {
           constraints.push(limit16(filters.pagination || 10));
           const q = query31(collection31(this.db, PROCEDURES_COLLECTION), ...constraints);
           const querySnapshot = await getDocs31(q);
-          const procedures = querySnapshot.docs.map(
+          let procedures = querySnapshot.docs.map(
             (doc45) => ({ ...doc45.data(), id: doc45.id })
           );
+          if (hasNestedFilters) {
+            procedures = this.applyInMemoryFilters(procedures, filters);
+          }
           const lastDoc = querySnapshot.docs.length > 0 ? querySnapshot.docs[querySnapshot.docs.length - 1] : null;
           console.log(`[PROCEDURE_SERVICE] Strategy 2 success: ${procedures.length} procedures`);
           if (procedures.length < (filters.pagination || 10)) {
@@ -17802,9 +17846,47 @@ var ProcedureService = class extends BaseService {
       }
       try {
         console.log(
-          "[PROCEDURE_SERVICE] Strategy 3: Using createdAt orderBy with client-side filtering"
+          "[PROCEDURE_SERVICE] Strategy 3: Using createdAt orderBy with client-side filtering",
+          {
+            procedureTechnology: filters.procedureTechnology,
+            hasTechnologyFilter: !!filters.procedureTechnology
+          }
+        );
+        const constraints = [];
+        if (filters.isActive !== void 0) {
+          constraints.push(where31("isActive", "==", filters.isActive));
+        } else {
+          constraints.push(where31("isActive", "==", true));
+        }
+        if (filters.procedureFamily) {
+          constraints.push(where31("family", "==", filters.procedureFamily));
+        }
+        if (filters.practitionerId) {
+          constraints.push(where31("practitionerId", "==", filters.practitionerId));
+        }
+        if (filters.clinicId) {
+          constraints.push(where31("clinicBranchId", "==", filters.clinicId));
+        }
+        if (filters.minPrice !== void 0) {
+          constraints.push(where31("price", ">=", filters.minPrice));
+        }
+        if (filters.maxPrice !== void 0) {
+          constraints.push(where31("price", "<=", filters.maxPrice));
+        }
+        if (filters.minRating !== void 0) {
+          constraints.push(where31("reviewInfo.averageRating", ">=", filters.minRating));
+        }
+        if (filters.maxRating !== void 0) {
+          constraints.push(where31("reviewInfo.averageRating", "<=", filters.maxRating));
+        }
+        if (filters.treatmentBenefits && filters.treatmentBenefits.length > 0) {
+          const benefitIdsToMatch = filters.treatmentBenefits;
+          constraints.push(where31("treatmentBenefitIds", "array-contains-any", benefitIdsToMatch));
+        }
+        console.log(
+          "[PROCEDURE_SERVICE] Strategy 3 Firestore constraints (nested filters excluded):",
+          constraints.map((c) => c.fieldPath || "unknown")
         );
-        const constraints = getBaseConstraints();
         constraints.push(orderBy18("createdAt", "desc"));
         if (filters.lastDoc) {
           if (typeof filters.lastDoc.data === "function") {
@@ -17821,7 +17903,20 @@ var ProcedureService = class extends BaseService {
         let procedures = querySnapshot.docs.map(
           (doc45) => ({ ...doc45.data(), id: doc45.id })
         );
+        console.log("[PROCEDURE_SERVICE] Before applyInMemoryFilters (Strategy 3):", {
+          procedureCount: procedures.length,
+          procedureTechnology: filters.procedureTechnology,
+          filtersObject: {
+            procedureTechnology: filters.procedureTechnology,
+            procedureFamily: filters.procedureFamily,
+            procedureCategory: filters.procedureCategory,
+            procedureSubcategory: filters.procedureSubcategory
+          }
+        });
         procedures = this.applyInMemoryFilters(procedures, filters);
+        console.log("[PROCEDURE_SERVICE] After applyInMemoryFilters (Strategy 3):", {
+          procedureCount: procedures.length
+        });
         const lastDoc = querySnapshot.docs.length > 0 ? querySnapshot.docs[querySnapshot.docs.length - 1] : null;
         console.log(`[PROCEDURE_SERVICE] Strategy 3 success: ${procedures.length} procedures`);
         if (procedures.length < (filters.pagination || 10)) {
@@ -17872,6 +17967,12 @@ var ProcedureService = class extends BaseService {
    */
   applyInMemoryFilters(procedures, filters) {
     let filteredProcedures = [...procedures];
+    console.log("[PROCEDURE_SERVICE] applyInMemoryFilters called:", {
+      procedureCount: procedures.length,
+      procedureTechnology: filters.procedureTechnology,
+      hasTechnologyFilter: !!filters.procedureTechnology,
+      allFilterKeys: Object.keys(filters).filter((k) => filters[k] !== void 0 && filters[k] !== null)
+    });
     if (filters.nameSearch && filters.nameSearch.trim()) {
       const searchTerm = filters.nameSearch.trim().toLowerCase();
       filteredProcedures = filteredProcedures.filter((procedure) => {
@@ -17947,6 +18048,7 @@ var ProcedureService = class extends BaseService {
       );
     }
     if (filters.procedureTechnology) {
+      const beforeCount = filteredProcedures.length;
       filteredProcedures = filteredProcedures.filter(
         (procedure) => {
           var _a;
@@ -17954,8 +18056,18 @@ var ProcedureService = class extends BaseService {
         }
       );
       console.log(
-        `[PROCEDURE_SERVICE] Applied technology filter, results: ${filteredProcedures.length}`
+        `[PROCEDURE_SERVICE] Applied technology filter (${filters.procedureTechnology}), before: ${beforeCount}, after: ${filteredProcedures.length}`
       );
+      if (beforeCount > filteredProcedures.length) {
+        const filteredOut = procedures.filter((p) => {
+          var _a;
+          return ((_a = p.technology) == null ? void 0 : _a.id) !== filters.procedureTechnology;
+        }).slice(0, 3).map((p) => {
+          var _a;
+          return { id: p.id, techId: (_a = p.technology) == null ? void 0 : _a.id, name: p.name };
+        });
+        console.log("[PROCEDURE_SERVICE] Filtered out sample procedures:", filteredOut);
+      }
     }
     if (filters.practitionerId) {
       filteredProcedures = filteredProcedures.filter(
@@ -18234,6 +18346,60 @@ var ReviewService = class extends BaseService {
   constructor(db, auth, app) {
     super(db, auth, app);
   }
+  /**
+   * Helper function to convert Firestore Timestamps to Date objects
+   * @param timestamp The timestamp to convert
+   * @returns A JavaScript Date object or null
+   */
+  convertTimestamp(timestamp) {
+    if (!timestamp) return /* @__PURE__ */ new Date();
+    if (timestamp && timestamp.__isTimestamp === true && typeof timestamp.seconds === "number") {
+      return new Date(timestamp.seconds * 1e3 + (timestamp.nanoseconds || 0) / 1e6);
+    }
+    if (timestamp && timestamp.toDate && typeof timestamp.toDate === "function") {
+      return timestamp.toDate();
+    }
+    if (timestamp instanceof Date) {
+      return timestamp;
+    }
+    if (typeof timestamp === "string" || typeof timestamp === "number") {
+      const date = new Date(timestamp);
+      if (!isNaN(date.getTime())) {
+        return date;
+      }
+    }
+    return /* @__PURE__ */ new Date();
+  }
+  /**
+   * Converts a Firestore document to a Review object with proper date handling
+   * @param docData The raw Firestore document data
+   * @returns A Review object with properly converted dates
+   */
+  convertDocToReview(docData) {
+    const review = docData;
+    review.createdAt = this.convertTimestamp(docData.createdAt);
+    review.updatedAt = this.convertTimestamp(docData.updatedAt);
+    if (review.clinicReview) {
+      review.clinicReview.createdAt = this.convertTimestamp(review.clinicReview.createdAt);
+      review.clinicReview.updatedAt = this.convertTimestamp(review.clinicReview.updatedAt);
+    }
+    if (review.practitionerReview) {
+      review.practitionerReview.createdAt = this.convertTimestamp(review.practitionerReview.createdAt);
+      review.practitionerReview.updatedAt = this.convertTimestamp(review.practitionerReview.updatedAt);
+    }
+    if (review.procedureReview) {
+      review.procedureReview.createdAt = this.convertTimestamp(review.procedureReview.createdAt);
+      review.procedureReview.updatedAt = this.convertTimestamp(review.procedureReview.updatedAt);
+    }
+    if (review.extendedProcedureReviews && Array.isArray(review.extendedProcedureReviews)) {
+      review.extendedProcedureReviews = review.extendedProcedureReviews.map((extReview) => ({
+        ...extReview,
+        createdAt: this.convertTimestamp(extReview.createdAt),
+        updatedAt: this.convertTimestamp(extReview.updatedAt)
+      }));
+    }
+    return review;
+  }
   /**
    * Creates a new review
    * @param data - The review data to create
@@ -18377,7 +18543,7 @@ var ReviewService = class extends BaseService {
       console.log("\u274C ReviewService.getReview - Review not found:", reviewId);
       return null;
     }
-    const review = { ...docSnap.data(), id: reviewId };
+    const review = { ...this.convertDocToReview(docSnap.data()), id: reviewId };
     try {
       const appointmentDoc = await getDoc39(
         doc38(this.db, APPOINTMENTS_COLLECTION, review.appointmentId)
@@ -18442,7 +18608,7 @@ var ReviewService = class extends BaseService {
   async getReviewsByPatient(patientId) {
     const q = query32(collection32(this.db, REVIEWS_COLLECTION), where32("patientId", "==", patientId));
     const snapshot = await getDocs32(q);
-    const reviews = snapshot.docs.map((doc45) => doc45.data());
+    const reviews = snapshot.docs.map((doc45) => this.convertDocToReview(doc45.data()));
     const enhancedReviews = await Promise.all(
       reviews.map(async (review) => {
         try {
@@ -18497,8 +18663,8 @@ var ReviewService = class extends BaseService {
     );
     const snapshot = await getDocs32(q);
     const reviews = snapshot.docs.map((doc45) => {
-      const data = doc45.data();
-      return { ...data, id: doc45.id };
+      const review = this.convertDocToReview(doc45.data());
+      return { ...review, id: doc45.id };
     });
     console.log("\u{1F50D} ReviewService.getReviewsByClinic - Found reviews before enhancement:", {
       clinicId,
@@ -18573,8 +18739,8 @@ var ReviewService = class extends BaseService {
     );
     const snapshot = await getDocs32(q);
     const reviews = snapshot.docs.map((doc45) => {
-      const data = doc45.data();
-      return { ...data, id: doc45.id };
+      const review = this.convertDocToReview(doc45.data());
+      return { ...review, id: doc45.id };
     });
     console.log("\u{1F50D} ReviewService.getReviewsByPractitioner - Found reviews before enhancement:", {
       practitionerId,
@@ -18720,7 +18886,7 @@ var ReviewService = class extends BaseService {
     if (snapshot.empty) {
       return null;
     }
-    return snapshot.docs[0].data();
+    return this.convertDocToReview(snapshot.docs[0].data());
   }
   /**
    * Deletes a review

package/package.json

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

package/src/admin/aggregation/appointment/appointment.aggregation.service.ts

@@ -37,6 +37,7 @@ import { AppointmentMailingService } from '../../mailing/appointment/appointment
 import { Logger } from '../../logger';
 import { UserRole } from '../../../types';
 import { CalendarEventStatus } from '../../../types/calendar';
+import { NotificationType } from '../../../types/notifications';
 
 // Mailgun client will be injected via constructor
 
@@ -540,6 +541,13 @@ export class AppointmentAggregationService {
         await this.handleZonePhotosUpdate(before, after);
       }
 
+      // Handle Recommended Procedures Added
+      const recommendationsChanged = this.hasRecommendationsChanged(before, after);
+      if (recommendationsChanged) {
+        Logger.info(`[AggService] Recommended procedures changed for appointment ${after.id}`);
+        await this.handleRecommendedProceduresUpdate(before, after, patientProfile);
+      }
+
       // TODO: Handle Review Added
       // const reviewAdded = !before.reviewInfo && after.reviewInfo;
       // if (reviewAdded) { ... }
@@ -1841,4 +1849,136 @@ export class AppointmentAggregationService {
       // Don't throw - this is a side effect and shouldn't break the main update flow
     }
   }
+
+  /**
+   * Checks if recommended procedures have changed between two appointment states
+   * @param before - The appointment state before update
+   * @param after - The appointment state after update
+   * @returns True if recommendations have changed, false otherwise
+   */
+  private hasRecommendationsChanged(before: Appointment, after: Appointment): boolean {
+    const beforeRecommendations = before.metadata?.recommendedProcedures || [];
+    const afterRecommendations = after.metadata?.recommendedProcedures || [];
+
+    // If lengths differ, there's a change
+    if (beforeRecommendations.length !== afterRecommendations.length) {
+      return true;
+    }
+
+    // Compare each recommendation (simple comparison - if any differ, return true)
+    // For simplicity, we compare by procedure ID and note
+    for (let i = 0; i < afterRecommendations.length; i++) {
+      const beforeRec = beforeRecommendations[i];
+      const afterRec = afterRecommendations[i];
+
+      if (!beforeRec || !afterRec) {
+        return true;
+      }
+
+      if (
+        beforeRec.procedure.procedureId !== afterRec.procedure.procedureId ||
+        beforeRec.note !== afterRec.note ||
+        beforeRec.timeframe.value !== afterRec.timeframe.value ||
+        beforeRec.timeframe.unit !== afterRec.timeframe.unit
+      ) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  /**
+   * Handles recommended procedures update - creates notifications for newly added recommendations
+   * @param before - The appointment state before update
+   * @param after - The appointment state after update
+   * @param patientProfile - The patient profile (for expo tokens)
+   */
+  private async handleRecommendedProceduresUpdate(
+    before: Appointment,
+    after: Appointment,
+    patientProfile: PatientProfile | null,
+  ): Promise<void> {
+    try {
+      const beforeRecommendations = before.metadata?.recommendedProcedures || [];
+      const afterRecommendations = after.metadata?.recommendedProcedures || [];
+
+      // Find newly added recommendations
+      const newRecommendations = afterRecommendations.slice(beforeRecommendations.length);
+
+      if (newRecommendations.length === 0) {
+        Logger.info(
+          `[AggService] No new recommendations detected for appointment ${after.id}`,
+        );
+        return;
+      }
+
+      Logger.info(
+        `[AggService] Found ${newRecommendations.length} new recommendation(s) for appointment ${after.id}`,
+      );
+
+      // Create notifications for each new recommendation
+      for (let i = 0; i < newRecommendations.length; i++) {
+        const recommendation = newRecommendations[i];
+        const recommendationIndex = beforeRecommendations.length + i;
+        const recommendationId = `${after.id}:${recommendationIndex}`;
+
+        // Format timeframe for display
+        const timeframeText = `${recommendation.timeframe.value} ${recommendation.timeframe.unit}${recommendation.timeframe.value > 1 ? 's' : ''}`;
+
+        // Create notification
+        const notificationPayload: Omit<
+          any,
+          'id' | 'createdAt' | 'updatedAt' | 'status' | 'isRead'
+        > = {
+          userId: after.patientId,
+          userRole: UserRole.PATIENT,
+          notificationType: NotificationType.PROCEDURE_RECOMMENDATION,
+          notificationTime: admin.firestore.Timestamp.now(),
+          notificationTokens: patientProfile?.expoTokens || [],
+          title: 'New Procedure Recommendation',
+          body: `${after.practitionerInfo?.name || 'Your doctor'} recommended "${recommendation.procedure.procedureName}" for you. Suggested timeframe: in ${timeframeText}`,
+          appointmentId: after.id,
+          recommendationId,
+          procedureId: recommendation.procedure.procedureId,
+          procedureName: recommendation.procedure.procedureName,
+          practitionerName: after.practitionerInfo?.name || 'Unknown Practitioner',
+          clinicName: after.clinicInfo?.name || 'Unknown Clinic',
+          note: recommendation.note,
+          timeframe: recommendation.timeframe,
+        };
+
+        try {
+          const notificationId = await this.notificationsAdmin.createNotification(
+            notificationPayload as any,
+          );
+
+          Logger.info(
+            `[AggService] Created notification ${notificationId} for recommendation ${recommendationId}`,
+          );
+
+          // Send push notification immediately if patient has tokens
+          if (patientProfile?.expoTokens && patientProfile.expoTokens.length > 0) {
+            const notification = await this.notificationsAdmin.getNotification(notificationId);
+            if (notification) {
+              await this.notificationsAdmin.sendPushNotification(notification);
+              Logger.info(
+                `[AggService] Sent push notification for recommendation ${recommendationId}`,
+              );
+            }
+          }
+        } catch (error) {
+          Logger.error(
+            `[AggService] Error creating notification for recommendation ${recommendationId}:`,
+            error,
+          );
+        }
+      }
+    } catch (error) {
+      Logger.error(
+        `[AggService] Error handling recommended procedures update for appointment ${after.id}:`,
+        error,
+      );
+    }
+  }
 }

package/src/backoffice/services/README.md

@@ -38,3 +38,20 @@ Manages administrative constants like treatment benefits and contraindications.
 - **`addContraindication(contraindication)`**: Adds a new contraindication.
 - **`updateContraindication(contraindication)`**: Updates an existing contraindication.
 - **`deleteContraindication(contraindicationId)`**: Deletes a contraindication.
+
+### `AnalyticsService` (Proposed)
+
+Comprehensive financial and analytical intelligence service for the Clinic Admin app. Provides insights about doctors, procedures, appointments, patients, products, and clinic operations.
+
+**Status**: Proposal phase - See [analytics.service.proposal.md](./analytics.service.proposal.md) for detailed design and implementation plan.
+
+**Planned Features**:
+- Practitioner performance analytics (appointments, cancellations, time efficiency, revenue)
+- Procedure analytics (popularity, profitability, product usage)
+- Appointment time analytics (booked vs actual time, efficiency metrics)
+- Cancellation & no-show analytics (by clinic, practitioner, patient, procedure)
+- Financial analytics (revenue, costs, payment status, trends)
+- Product usage analytics (usage patterns, revenue contribution)
+- Patient analytics (lifetime value, retention, appointment frequency)
+- Clinic analytics (performance metrics, comparisons)
+- Comprehensive dashboard data aggregation