Merge pull request #218 from Plant-for-the-Planet-org/develop

Merge: notification-fix, env-cleanup

Author: rupamkairi

.gitignore

@@ -6,4 +6,4 @@ node_modules
 .DS_Store
 .turbo
 .idea
-.vercel
+.vercel

.prettierignore

@@ -1 +0,0 @@
-**

apps/server/.prettierrc.cjs

@@ -0,0 +1,7 @@
+module.exports = {
+  arrowParens: "avoid",
+  bracketSameLine: true,
+  bracketSpacing: false,
+  singleQuote: true,
+  trailingComma: "all",
+};

apps/server/prisma/migrations/20250428162841_notifications_issue_tracking_fields/migration.sql

@@ -0,0 +1,3 @@
+-- AlterTable
+ALTER TABLE "Notification" ADD COLUMN     "isSkipped" BOOLEAN NOT NULL DEFAULT false,
+ADD COLUMN     "metadata" JSONB;

apps/server/prisma/schema.prisma

@@ -79,7 +79,7 @@ model Site {
     slices             Json? // Will be something like ["1","2"] or ["3"] or ["1"] or ["7","8"]
     detectionGeometry  Unsupported("geometry")?
     originalGeometry   Unsupported("geometry")?
-    detectionArea      Float?
+    detectionArea      Float?                   @default(0)
     alerts             SiteAlert[]
     project            Project?                 @relation(fields: [projectId], references: [id])
     user               User                     @relation(fields: [userId], references: [id], onDelete: Cascade)
@@ -149,6 +149,8 @@ model Notification {
     destination String
     sentAt      DateTime?
     isDelivered Boolean   @default(false)
+    isSkipped   Boolean   @default(false)
+    metadata    Json?
 }
 
 model Stats {

apps/server/src/Interfaces/AdditionalOptions.ts

@@ -0,0 +1,6 @@
+import type {NextApiRequest, NextApiResponse} from 'next';
+
+export interface AdditionalOptions {
+  req?: NextApiRequest;
+  res?: NextApiResponse;
+}

apps/server/src/Interfaces/NotificationParameters.ts

@@ -6,8 +6,8 @@ export interface NotificationParameters {
   subject?: string;
   url?: string;
   authenticationMessage?: boolean;
-  otp?: string,
-  siteName?: string,
+  otp?: string;
+  siteName?: string;
   alert?: {
     id: string;
     type: string;
@@ -21,4 +21,10 @@ export interface NotificationParameters {
     siteId: string;
     siteName: string;
   };
+  site?: {
+    id: string;
+  };
+  user?: {
+    id: string;
+  };
 }

apps/server/src/Services/Notifications/SendNotifications.ts

@@ -1,25 +1,40 @@
+import type {AdditionalOptions} from '../../Interfaces/AdditionalOptions';
 import {type AlertMethodMethod} from '../../Interfaces/AlertMethod';
-import NotifierRegistry from '../Notifier/NotifierRegistry';
-import {type NotificationParameters} from '../../Interfaces/NotificationParameters';
 import type DataRecord from '../../Interfaces/DataRecord';
+import {type NotificationParameters} from '../../Interfaces/NotificationParameters';
+import {getLocalTime} from '../../../src/utils/date';
+import {env} from '../../env.mjs';
 import {prisma} from '../../server/db';
 import {logger} from '../../server/logger';
-import {getLocalTime} from '../../../src/utils/date';
+import NotifierRegistry from '../Notifier/NotifierRegistry';
+import {NOTIFICATION_METHOD} from '../Notifier/methodConstants';
+
+const MAX_RETRIES = 0;
+const ALERT_SMS_DISABLED = env.ALERT_SMS_DISABLED;
+const ALERT_WHATSAPP_DISABLED = env.ALERT_WHATSAPP_DISABLED;
 
 // get all undelivered Notifications and using relation from SiteAlert, get the data on Site
 // for each notification, send the notification to the destination
 // After sending notification update the notification table to set isDelivered to true and sentAt to current time
 // If notification fails to send, increment the failCount in all alertMethods table where destination and method match.
-const sendNotifications = async (): Promise<number> => {
+const sendNotifications = async ({req}: AdditionalOptions): Promise<number> => {
+  const alertMethodsExclusionList = [];
+  if (ALERT_SMS_DISABLED)
+    alertMethodsExclusionList.push(NOTIFICATION_METHOD.SMS);
+  if (ALERT_WHATSAPP_DISABLED)
+    alertMethodsExclusionList.push(NOTIFICATION_METHOD.WHATSAPP);
+
   const take = 10;
   let successCount = 0;
   let continueProcessing = true;
+  let retries = 0;
   while (continueProcessing) {
     const notifications = await prisma.notification.findMany({
       where: {
+        isSkipped: false,
         isDelivered: false,
         sentAt: null,
-        alertMethod: {notIn: ['sms', 'whatsapp']}
+        alertMethod: {notIn: alertMethodsExclusionList},
       },
       include: {
         siteAlert: {
@@ -40,13 +55,17 @@ const sendNotifications = async (): Promise<number> => {
     logger(`Notifications to be sent: ${notifications.length}`, 'info');
 
     const successfulNotificationIds: string[] = [];
-    const failedAlertMethods: { destination: string; method: AlertMethodMethod }[] = [];
+    const successfulDestinations: string[] = [];
+    const failedAlertMethods: {
+      destination: string;
+      method: AlertMethodMethod;
+    }[] = [];
 
     await Promise.all(
       notifications.map(async notification => {
         try {
           const {id, destination, siteAlert} = notification;
-          const alertMethod = notification.alertMethod as AlertMethodMethod
+          const alertMethod = notification.alertMethod as AlertMethodMethod;
           const {
             id: alertId,
             confidence,
@@ -59,6 +78,8 @@ const sendNotifications = async (): Promise<number> => {
             eventDate,
             site,
           } = siteAlert;
+          // const siteId = site.id;
+          // const userId = site.userId;
 
           // if distance = 0 then the fire is inside the site's original geometry
           // if distance > 0 then the fire is outside the site's original geometry
@@ -144,53 +165,64 @@ const sendNotifications = async (): Promise<number> => {
               siteName: siteName,
               data: data as DataRecord,
             },
+            // site: {id: siteId},
+            // user: {id: userId!},
           };
           const notifier = NotifierRegistry.get(alertMethod);
 
           const isDelivered = await notifier.notify(
             destination,
             notificationParameters,
+            {req},
           );
 
           if (isDelivered === true) {
             successfulNotificationIds.push(id);
+            successfulDestinations.push(destination);
             successCount++;
           } else {
-            failedAlertMethods.push({ destination, method: alertMethod });
+            failedAlertMethods.push({destination, method: alertMethod});
           }
         } catch (error) {
-          logger(`Error processing notification ${notification.id}:`, 'error');
+          logger(
+            `Error processing notification ${notification.id}: ${
+              (error as Error)?.message
+            }`,
+            'error',
+          );
         }
-      })
+      }),
     );
 
-    // UpdateMany notification 
+    // UpdateMany notification
     if (successfulNotificationIds.length > 0) {
       await prisma.notification.updateMany({
-        where: {
-          id: {
-            in: successfulNotificationIds,
-          },
-        },
-        data: {
-          isDelivered: true,
-          sentAt: new Date(),
-        },
+        where: {id: {in: successfulNotificationIds}},
+        data: {isDelivered: true, sentAt: new Date()},
       });
-    }
-    // Handle failed notifications
-    for (const { destination, method } of failedAlertMethods) {
       await prisma.alertMethod.updateMany({
-        where: {
-          destination: destination,
-          method: method,
-        },
-        data: {
-          failCount: {
-            increment: 1,
-          },
-        },
+        where: {destination: {in: successfulDestinations}},
+        data: {failCount: 0},
+      });
+    }
+
+    retries += 1;
+    if (retries >= MAX_RETRIES) {
+      const unsuccessfulNotifications = notifications.filter(
+        ({id}) => !successfulNotificationIds.includes(id),
+      );
+
+      const unsuccessfulNotificationIds = unsuccessfulNotifications.map(
+        ({id}) => id,
+      );
+
+      await prisma.notification.updateMany({
+        where: {id: {in: unsuccessfulNotificationIds}},
+        data: {isSkipped: true, isDelivered: false, sentAt: null},
       });
+
+      continueProcessing = false;
+      break;
     }
 
     // skip += take; No need to skip take as we update the notifications to isDelivered = true

apps/server/src/Services/Notifier/Notifier.ts

@@ -1,11 +1,18 @@
-import {type NotificationParameters} from '../../Interfaces/NotificationParameters';
+import type {AdditionalOptions} from '../../Interfaces/AdditionalOptions';
+import type {NotificationParameters} from '../../Interfaces/NotificationParameters';
+import type {HandleFailedNotificationOptions} from './handleFailedNotification';
 
 interface Notifier {
   getSupportedMethods: () => string[];
   notify: (
     destination: string,
     parameters: NotificationParameters,
+    options?: AdditionalOptions,
   ) => Promise<boolean>;
+
+  handleFailedNotification?: (
+    opts: HandleFailedNotificationOptions,
+  ) => Promise<void>;
 }
 
 export default Notifier;

apps/server/src/Services/Notifier/Notifier/DeviceNotifier.ts

@@ -4,13 +4,17 @@ import {NOTIFICATION_METHOD} from '../methodConstants';
 import {env} from '../../../env.mjs';
 import {logger} from '../../../server/logger';
 import {prisma} from '../../../server/db';
+import {handleFailedNotification as genericFailedNotificationHandler} from '../handleFailedNotification';
 
 class DeviceNotifier implements Notifier {
   getSupportedMethods(): Array<string> {
     return [NOTIFICATION_METHOD.DEVICE];
   }
 
-  async deleteNotificationAndDevice(destination: string, notificationId: string): Promise<void> {
+  async deleteNotificationAndDevice(
+    destination: string,
+    notificationId: string,
+  ): Promise<void> {
     try {
       // Delete the notification
       await prisma.notification.delete({
@@ -23,11 +27,17 @@ class DeviceNotifier implements Notifier {
         where: {
           destination: destination,
           method: NOTIFICATION_METHOD.DEVICE,
-        }
+        },
       });
-      logger(`Notification with ID: ${notificationId} deleted and alertMethod for destination: ${destination} has been unverified and disabled.`, "info");
+      logger(
+        `Notification with ID: ${notificationId} deleted and alertMethod for destination: ${destination} has been unverified and disabled.`,
+        'info',
+      );
     } catch (error) {
-      logger(`Database Error: Couldn't modify the alertMethod or delete the notification: ${error}`, "error");
+      logger(
+        `Database Error: Couldn't modify the alertMethod or delete the notification: ${error}`,
+        'error',
+      );
     }
   }
 
@@ -41,6 +51,12 @@ class DeviceNotifier implements Notifier {
   ): Promise<boolean> {
     const {message, subject, url, alert} = parameters;
 
+    // Check if OneSignal is configured
+    if (!env.ONESIGNAL_APP_ID || !env.ONESIGNAL_REST_API_KEY) {
+      logger(`Push notifications are disabled: OneSignal is not configured`, 'warn');
+      return Promise.resolve(false);
+    }
+
     // logger(`Sending message ${message} to ${destination}`, "info");
 
     // construct the payload for the OneSignal API
@@ -62,21 +78,29 @@ class DeviceNotifier implements Notifier {
       },
       body: JSON.stringify(payload),
     });
-    console.log(response);
+    // console.log(response);
     if (!response.ok) {
       logger(
         `Failed to send device notification. Error: ${response.statusText} for ${parameters.id}`,
         'error',
       );
+
+      await this.handleFailedNotification({
+        destination: destination,
+        method: NOTIFICATION_METHOD.DEVICE,
+      });
+
       // If device not found
-      if(response.status === 404){
-        await this.deleteNotificationAndDevice(destination, parameters.id)
-      }
+      // if (response.status === 404) {
+      //   await this.deleteNotificationAndDevice(destination, parameters.id);
+      // }
       return false;
     }
 
     return true;
   }
+
+  handleFailedNotification = genericFailedNotificationHandler;
 }
 
 export default DeviceNotifier;