@blackcode_sa/metaestetics-api 1.6.15 → 1.6.17

package/src/admin/notifications/notifications.admin.ts

@@ -9,6 +9,7 @@ import { Appointment, PaymentStatus } from "../../types/appointment";
 import { UserRole } from "../../types";
 import { Timestamp as FirebaseClientTimestamp } from "@firebase/firestore";
 import { TimestampUtils } from "../../utils/TimestampUtils";
+import { Logger } from "../logger";
 
 export class NotificationsAdmin {
   private expo: Expo;
@@ -46,19 +47,31 @@ export class NotificationsAdmin {
    * Priprema Expo poruku za slanje
    */
   private prepareExpoMessage(notification: Notification): ExpoPushMessage[] {
-    return notification.notificationTokens
-      .filter((token) => Expo.isExpoPushToken(token))
-      .map((token) => ({
-        to: token,
-        sound: "default",
-        title: notification.title,
-        body: notification.body,
-        data: {
-          notificationId: notification.id,
-          notificationType: notification.notificationType,
-          userId: notification.userId,
-        },
-      }));
+    const validTokens = notification.notificationTokens.filter((token) =>
+      Expo.isExpoPushToken(token)
+    );
+
+    Logger.info(
+      `[NotificationsAdmin] Preparing Expo messages for notification ${notification.id}`,
+      {
+        totalTokens: notification.notificationTokens.length,
+        validTokens: validTokens.length,
+        invalidTokensCount:
+          notification.notificationTokens.length - validTokens.length,
+      }
+    );
+
+    return validTokens.map((token) => ({
+      to: token,
+      sound: "default",
+      title: notification.title,
+      body: notification.body,
+      data: {
+        notificationId: notification.id,
+        notificationType: notification.notificationType,
+        userId: notification.userId,
+      },
+    }));
   }
 
   /**
@@ -93,27 +106,58 @@ export class NotificationsAdmin {
    */
   async sendPushNotification(notification: Notification): Promise<boolean> {
     try {
+      Logger.info(
+        `[NotificationsAdmin] Processing notification ${notification.id} for sending`,
+        {
+          userId: notification.userId,
+          tokenCount: notification.notificationTokens?.length || 0,
+          type: notification.notificationType,
+        }
+      );
+
       const messages = this.prepareExpoMessage(notification);
 
       if (messages.length === 0) {
+        const errorMsg = "No valid notification tokens found";
+        Logger.error(
+          `[NotificationsAdmin] ${errorMsg} for notification ${notification.id}`
+        );
         await this.updateNotificationStatus(
           notification.id!,
           NotificationStatus.FAILED,
-          "No valid notification tokens found"
+          errorMsg
         );
         return false;
       }
 
       const chunks = this.expo.chunkPushNotifications(messages);
+      Logger.info(
+        `[NotificationsAdmin] Sending ${messages.length} messages in ${chunks.length} chunks for notification ${notification.id}`
+      );
+
       const tickets: ExpoPushTicket[][] = [];
 
       // Šaljemo sve chunks
-      for (const chunk of chunks) {
+      for (let i = 0; i < chunks.length; i++) {
+        const chunk = chunks[i];
         try {
+          Logger.info(
+            `[NotificationsAdmin] Sending chunk ${i + 1}/${
+              chunks.length
+            } with ${chunk.length} messages`
+          );
           const ticketChunk = await this.expo.sendPushNotificationsAsync(chunk);
+          Logger.info(
+            `[NotificationsAdmin] Received ${
+              ticketChunk.length
+            } tickets for chunk ${i + 1}`
+          );
           tickets.push(ticketChunk);
         } catch (error) {
-          console.error(`Chunk sending error:`, error);
+          Logger.error(
+            `[NotificationsAdmin] Chunk ${i + 1} sending error:`,
+            error
+          );
           throw error;
         }
       }
@@ -121,25 +165,62 @@ export class NotificationsAdmin {
       // Proveravamo rezultate
       let hasErrors = false;
       const errors: string[] = [];
+      const ticketsFlat = tickets.flat();
 
-      tickets.flat().forEach((ticket, index) => {
+      // Log detailed ticket information
+      const ticketResults = {
+        total: ticketsFlat.length,
+        success: 0,
+        error: 0,
+        errorDetails: {} as Record<string, number>,
+      };
+
+      ticketsFlat.forEach((ticket, index) => {
         if (ticket.status === "error") {
           hasErrors = true;
-          errors.push(
-            `Token ${notification.notificationTokens[index]}: ${ticket.message}`
-          );
+          ticketResults.error++;
+
+          // Count each error type
+          const errorMessage = ticket.message || "Unknown error";
+          ticketResults.errorDetails[errorMessage] =
+            (ticketResults.errorDetails[errorMessage] || 0) + 1;
+
+          const tokenInfo =
+            index < notification.notificationTokens.length
+              ? `Token ${notification.notificationTokens[index]}`
+              : `Token at index ${index}`;
+
+          errors.push(`${tokenInfo}: ${errorMessage}`);
+        } else {
+          ticketResults.success++;
         }
       });
 
+      Logger.info(
+        `[NotificationsAdmin] Ticket results for notification ${notification.id}`,
+        ticketResults
+      );
+
       if (hasErrors) {
+        const errorSummary = errors.join("; ");
+        Logger.warn(
+          `[NotificationsAdmin] Partial success or errors in notification ${notification.id}`,
+          { errorCount: errors.length, errorSummary }
+        );
+
         await this.updateNotificationStatus(
           notification.id!,
-          NotificationStatus.PARTIAL_SUCCESS,
-          errors.join("; ")
+          ticketResults.success > 0
+            ? NotificationStatus.PARTIAL_SUCCESS
+            : NotificationStatus.FAILED,
+          errorSummary
         );
-        return false;
+        return ticketResults.success > 0;
       }
 
+      Logger.info(
+        `[NotificationsAdmin] Successfully sent notification ${notification.id} to all recipients`
+      );
       await this.updateNotificationStatus(
         notification.id!,
         NotificationStatus.SENT
@@ -148,7 +229,10 @@ export class NotificationsAdmin {
     } catch (error) {
       const errorMessage =
         error instanceof Error ? error.message : "Unknown error";
-      console.error("Greška pri slanju notifikacije:", error);
+      Logger.error(
+        `[NotificationsAdmin] Critical error sending notification ${notification.id}:`,
+        error
+      );
       await this.updateNotificationStatus(
         notification.id!,
         NotificationStatus.FAILED,
@@ -164,6 +248,10 @@ export class NotificationsAdmin {
   async processPendingNotifications(batchSize: number = 100): Promise<void> {
     const now = admin.firestore.Timestamp.now();
 
+    Logger.info(
+      `[NotificationsAdmin] Starting to process pending notifications with batch size ${batchSize}`
+    );
+
     const pendingNotifications = await this.db
       .collection("notifications")
       .where("status", "==", NotificationStatus.PENDING)
@@ -171,12 +259,27 @@ export class NotificationsAdmin {
       .limit(batchSize)
       .get();
 
+    Logger.info(
+      `[NotificationsAdmin] Found ${pendingNotifications.size} pending notifications to process`
+    );
+
+    if (pendingNotifications.empty) {
+      Logger.info(
+        "[NotificationsAdmin] No pending notifications found to process"
+      );
+      return;
+    }
+
     const results = await Promise.allSettled(
       pendingNotifications.docs.map(async (doc) => {
         const notification = {
           id: doc.id,
           ...doc.data(),
         } as Notification;
+
+        Logger.info(
+          `[NotificationsAdmin] Processing notification ${notification.id} of type ${notification.notificationType}`
+        );
         return this.sendPushNotification(notification);
       })
     );
@@ -189,8 +292,8 @@ export class NotificationsAdmin {
       (r) => r.status === "rejected" || (r.status === "fulfilled" && !r.value)
     ).length;
 
-    console.log(
-      `Processed ${results.length} notifications: ${successful} successful, ${failed} failed`
+    Logger.info(
+      `[NotificationsAdmin] Processed ${results.length} notifications: ${successful} successful, ${failed} failed`
     );
   }
 
@@ -204,6 +307,11 @@ export class NotificationsAdmin {
     const cutoffDate = new Date();
     cutoffDate.setDate(cutoffDate.getDate() - daysOld);
 
+    Logger.info(
+      `[NotificationsAdmin] Starting cleanup of notifications older than ${daysOld} days`
+    );
+
+    let totalDeleted = 0;
     while (true) {
       const oldNotifications = await this.db
         .collection("notifications")
@@ -216,6 +324,9 @@ export class NotificationsAdmin {
         .get();
 
       if (oldNotifications.empty) {
+        Logger.info(
+          `[NotificationsAdmin] No more old notifications to delete. Total deleted: ${totalDeleted}`
+        );
         break;
       }
 
@@ -225,8 +336,9 @@ export class NotificationsAdmin {
       });
 
       await batch.commit();
-      console.log(
-        `Deleted batch of ${oldNotifications.size} old notifications`
+      totalDeleted += oldNotifications.size;
+      Logger.info(
+        `[NotificationsAdmin] Deleted batch of ${oldNotifications.size} old notifications. Running total: ${totalDeleted}`
       );
     }
   }

package/src/services/appointment/appointment.service.ts

@@ -5,6 +5,14 @@ import {
   serverTimestamp,
   arrayUnion,
   arrayRemove,
+  QueryConstraint,
+  where,
+  orderBy,
+  collection,
+  query,
+  limit,
+  startAfter,
+  getDocs,
 } from "firebase/firestore";
 import { Auth } from "firebase/auth";
 import { FirebaseApp } from "firebase/app";
@@ -21,6 +29,7 @@ import {
   PatientReviewInfo,
   LinkedFormInfo,
   type CreateAppointmentHttpData,
+  APPOINTMENTS_COLLECTION,
 } from "../../types/appointment";
 import {
   createAppointmentSchema,
@@ -1002,4 +1011,233 @@ export class AppointmentService extends BaseService {
 
     return this.updateAppointment(appointmentId, updateData);
   }
+
+  /**
+   * Gets upcoming appointments for a specific patient.
+   * These include appointments with statuses: PENDING, CONFIRMED, CHECKED_IN, IN_PROGRESS
+   *
+   * @param patientId ID of the patient
+   * @param options Optional parameters for filtering and pagination
+   * @returns Found appointments and the last document for pagination
+   */
+  async getUpcomingPatientAppointments(
+    patientId: string,
+    options?: {
+      startDate?: Date; // Optional starting date (defaults to now)
+      endDate?: Date;
+      limit?: number;
+      startAfter?: DocumentSnapshot;
+    }
+  ): Promise<{
+    appointments: Appointment[];
+    lastDoc: DocumentSnapshot | null;
+  }> {
+    try {
+      console.log(
+        `[APPOINTMENT_SERVICE] Getting upcoming appointments for patient: ${patientId}`
+      );
+
+      // Default to current date/time if no startDate provided
+      const effectiveStartDate = options?.startDate || new Date();
+
+      // Define the statuses considered as "upcoming"
+      const upcomingStatuses = [
+        AppointmentStatus.PENDING,
+        AppointmentStatus.CONFIRMED,
+        AppointmentStatus.CHECKED_IN,
+        AppointmentStatus.IN_PROGRESS,
+        AppointmentStatus.RESCHEDULED_BY_CLINIC,
+      ];
+
+      // Build query constraints
+      const constraints: QueryConstraint[] = [];
+
+      // Patient ID filter
+      constraints.push(where("patientId", "==", patientId));
+
+      // Status filter - multiple statuses
+      constraints.push(where("status", "in", upcomingStatuses));
+
+      // Date range filters
+      constraints.push(
+        where(
+          "appointmentStartTime",
+          ">=",
+          Timestamp.fromDate(effectiveStartDate)
+        )
+      );
+
+      if (options?.endDate) {
+        constraints.push(
+          where(
+            "appointmentStartTime",
+            "<=",
+            Timestamp.fromDate(options.endDate)
+          )
+        );
+      }
+
+      // Order by appointment start time (ascending for upcoming - closest first)
+      constraints.push(orderBy("appointmentStartTime", "asc"));
+
+      // Add pagination if specified
+      if (options?.limit) {
+        constraints.push(limit(options.limit));
+      }
+
+      if (options?.startAfter) {
+        constraints.push(startAfter(options.startAfter));
+      }
+
+      // Execute query
+      const q = query(
+        collection(this.db, APPOINTMENTS_COLLECTION),
+        ...constraints
+      );
+      const querySnapshot = await getDocs(q);
+
+      // Extract results
+      const appointments = querySnapshot.docs.map(
+        (doc) => doc.data() as Appointment
+      );
+
+      // Get last document for pagination
+      const lastDoc =
+        querySnapshot.docs.length > 0
+          ? querySnapshot.docs[querySnapshot.docs.length - 1]
+          : null;
+
+      console.log(
+        `[APPOINTMENT_SERVICE] Found ${appointments.length} upcoming appointments for patient ${patientId}`
+      );
+
+      return { appointments, lastDoc };
+    } catch (error) {
+      console.error(
+        `[APPOINTMENT_SERVICE] Error getting upcoming appointments for patient ${patientId}:`,
+        error
+      );
+      throw error;
+    }
+  }
+
+  /**
+   * Gets past appointments for a specific patient.
+   * These include appointments with statuses: COMPLETED, CANCELED_PATIENT,
+   * CANCELED_PATIENT_RESCHEDULED, CANCELED_CLINIC, NO_SHOW
+   *
+   * @param patientId ID of the patient
+   * @param options Optional parameters for filtering and pagination
+   * @returns Found appointments and the last document for pagination
+   */
+  async getPastPatientAppointments(
+    patientId: string,
+    options?: {
+      startDate?: Date;
+      endDate?: Date; // Optional end date (defaults to now)
+      showCanceled?: boolean; // Whether to include canceled appointments
+      showNoShow?: boolean; // Whether to include no-show appointments
+      limit?: number;
+      startAfter?: DocumentSnapshot;
+    }
+  ): Promise<{
+    appointments: Appointment[];
+    lastDoc: DocumentSnapshot | null;
+  }> {
+    try {
+      console.log(
+        `[APPOINTMENT_SERVICE] Getting past appointments for patient: ${patientId}`
+      );
+
+      // Default to current date/time if no endDate provided
+      const effectiveEndDate = options?.endDate || new Date();
+
+      // Define the base status for past appointments
+      const pastStatuses: AppointmentStatus[] = [AppointmentStatus.COMPLETED];
+
+      // Add canceled statuses if requested
+      if (options?.showCanceled) {
+        pastStatuses.push(
+          AppointmentStatus.CANCELED_PATIENT,
+          AppointmentStatus.CANCELED_PATIENT_RESCHEDULED,
+          AppointmentStatus.CANCELED_CLINIC
+        );
+      }
+
+      // Add no-show status if requested
+      if (options?.showNoShow) {
+        pastStatuses.push(AppointmentStatus.NO_SHOW);
+      }
+
+      // Build query constraints
+      const constraints: QueryConstraint[] = [];
+
+      // Patient ID filter
+      constraints.push(where("patientId", "==", patientId));
+
+      // Status filter - multiple statuses
+      constraints.push(where("status", "in", pastStatuses));
+
+      // Date range filters
+      if (options?.startDate) {
+        constraints.push(
+          where(
+            "appointmentStartTime",
+            ">=",
+            Timestamp.fromDate(options.startDate)
+          )
+        );
+      }
+
+      constraints.push(
+        where(
+          "appointmentStartTime",
+          "<=",
+          Timestamp.fromDate(effectiveEndDate)
+        )
+      );
+
+      // Order by appointment start time (descending for past - most recent first)
+      constraints.push(orderBy("appointmentStartTime", "desc"));
+
+      // Add pagination if specified
+      if (options?.limit) {
+        constraints.push(limit(options.limit));
+      }
+
+      if (options?.startAfter) {
+        constraints.push(startAfter(options.startAfter));
+      }
+
+      // Execute query
+      const q = query(
+        collection(this.db, APPOINTMENTS_COLLECTION),
+        ...constraints
+      );
+      const querySnapshot = await getDocs(q);
+
+      // Extract results
+      const appointments = querySnapshot.docs.map(
+        (doc) => doc.data() as Appointment
+      );
+
+      // Get last document for pagination
+      const lastDoc =
+        querySnapshot.docs.length > 0
+          ? querySnapshot.docs[querySnapshot.docs.length - 1]
+          : null;
+
+      console.log(
+        `[APPOINTMENT_SERVICE] Found ${appointments.length} past appointments for patient ${patientId}`
+      );
+
+      return { appointments, lastDoc };
+    } catch (error) {
+      console.error(
+        `[APPOINTMENT_SERVICE] Error getting past appointments for patient ${patientId}:`,
+        error
+      );
+      throw error;
+    }
+  }
 }