@oneuptime/common 7.0.4707 → 7.0.4720

package/Server/Services/OnCallDutyPolicyScheduleService.ts

@@ -34,6 +34,8 @@ import { Green500 } from "../../Types/BrandColors";
 import OnCallDutyPolicyTimeLogService from "./OnCallDutyPolicyTimeLogService";
 import DeleteBy from "../Types/Database/DeleteBy";
 import { OnDelete } from "../Types/Database/Hooks";
+import PushNotificationMessage from "../../Types/PushNotification/PushNotificationMessage";
+import PushNotificationUtil from "../Utils/PushNotificationUtil";
 
 export class Service extends DatabaseService<OnCallDutyPolicySchedule> {
   private layerUtil = new LayerUtil();
@@ -253,12 +255,21 @@ export class Service extends DatabaseService<OnCallDutyPolicySchedule> {
             ],
           };
 
+          const pushMessage: PushNotificationMessage =
+            PushNotificationUtil.createGenericNotification({
+              title: "On-Call Duty Ended",
+              body: `You are no longer on-call for ${onCallPolicy.name!} as your roster on schedule ${onCallSchedule.name} has ended.`,
+              tag: "on-call-duty-ended",
+              requireInteraction: false,
+            });
+
           await UserNotificationSettingService.sendUserNotification({
             userId: sendEmailToUserId,
             projectId: projectId,
             emailEnvelope: emailMessage,
             smsMessage: sms,
             callRequestMessage: callMessage,
+            pushNotificationMessage: pushMessage,
             eventType:
               NotificationSettingEventType.SEND_WHEN_USER_IS_NO_LONGER_ACTIVE_ON_ON_CALL_ROSTER,
           });
@@ -360,12 +371,21 @@ export class Service extends DatabaseService<OnCallDutyPolicySchedule> {
             ],
           };
 
+          const pushMessage: PushNotificationMessage =
+            PushNotificationUtil.createGenericNotification({
+              title: "On-Call Duty Started",
+              body: `You are now on-call for ${onCallPolicy.name!} on schedule ${onCallSchedule.name}.`,
+              tag: "on-call-duty-started",
+              requireInteraction: true,
+            });
+
           await UserNotificationSettingService.sendUserNotification({
             userId: sendEmailToUserId,
             projectId: projectId,
             emailEnvelope: emailMessage,
             smsMessage: sms,
             callRequestMessage: callMessage,
+            pushNotificationMessage: pushMessage,
             eventType:
               NotificationSettingEventType.SEND_WHEN_USER_IS_ON_CALL_ROSTER,
           });
@@ -487,12 +507,21 @@ export class Service extends DatabaseService<OnCallDutyPolicySchedule> {
             ],
           };
 
+          const pushMessage: PushNotificationMessage =
+            PushNotificationUtil.createGenericNotification({
+              title: "Next On-Call Duty",
+              body: `You are next on-call for ${onCallPolicy.name!} on schedule ${onCallSchedule.name}.`,
+              tag: "next-on-call-duty",
+              requireInteraction: false,
+            });
+
           await UserNotificationSettingService.sendUserNotification({
             userId: sendEmailToUserId,
             projectId: projectId,
             emailEnvelope: emailMessage,
             smsMessage: sms,
             callRequestMessage: callMessage,
+            pushNotificationMessage: pushMessage,
             eventType:
               NotificationSettingEventType.SEND_WHEN_USER_IS_NEXT_ON_CALL_ROSTER,
           });

package/Server/Services/ProbeService.ts

@@ -28,6 +28,8 @@ import DatabaseConfig from "../DatabaseConfig";
 import URL from "../../Types/API/URL";
 import UpdateBy from "../Types/Database/UpdateBy";
 import MonitorService from "./MonitorService";
+import PushNotificationMessage from "../../Types/PushNotification/PushNotificationMessage";
+import PushNotificationUtil from "../Utils/PushNotificationUtil";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import { IsBillingEnabled } from "../EnvironmentConfig";
 import GlobalCache from "../Infrastructure/GlobalCache";
@@ -365,12 +367,33 @@ export class Service extends DatabaseService<Model> {
           ],
         };
 
+        const pushMessageParams: {
+          probeName: string;
+          projectName: string;
+          connectionStatus: string;
+          clickAction?: string;
+        } = {
+          probeName: probe.name!,
+          projectName: probe.project?.name || "Project",
+          connectionStatus: connectionStatus,
+        };
+
+        if (vars["viewProbesLink"]) {
+          pushMessageParams.clickAction = vars["viewProbesLink"];
+        }
+
+        const pushMessage: PushNotificationMessage =
+          PushNotificationUtil.createProbeStatusChangedNotification(
+            pushMessageParams,
+          );
+
         await UserNotificationSettingService.sendUserNotification({
           userId: user.id!,
           projectId: probe.projectId!,
           emailEnvelope: emailMessage,
           smsMessage: sms,
           callRequestMessage: callMessage,
+          pushNotificationMessage: pushMessage,
           eventType:
             NotificationSettingEventType.SEND_PROBE_STATUS_CHANGED_OWNER_NOTIFICATION,
         });

package/Server/Services/PushNotificationService.ts

@@ -0,0 +1,253 @@
+import PushNotificationRequest from "../../Types/PushNotification/PushNotificationRequest";
+import PushNotificationMessage from "../../Types/PushNotification/PushNotificationMessage";
+import ObjectID from "../../Types/ObjectID";
+import logger from "../Utils/Logger";
+import UserPushService from "./UserPushService";
+import UserOnCallLogTimelineService from "./UserOnCallLogTimelineService";
+import UserNotificationStatus from "../../Types/UserNotification/UserNotificationStatus";
+import {
+  VapidPublicKey,
+  VapidPrivateKey,
+  VapidSubject,
+} from "../EnvironmentConfig";
+import webpush from "web-push";
+import PushNotificationUtil from "../Utils/PushNotificationUtil";
+import { LIMIT_PER_PROJECT } from "../../Types/Database/LimitMax";
+import UserPush from "../../Models/DatabaseModels/UserPush";
+
+export interface PushNotificationOptions {
+  projectId?: ObjectID | undefined;
+  isSensitive?: boolean;
+  userOnCallLogTimelineId?: ObjectID | undefined;
+}
+
+export default class PushNotificationService {
+  public static isWebPushInitialized = false;
+
+  public static initializeWebPush(): void {
+    if (this.isWebPushInitialized) {
+      return;
+    }
+
+    if (!VapidPublicKey || !VapidPrivateKey) {
+      logger.warn(
+        "VAPID keys not configured. Web push notifications will not work.",
+      );
+      logger.warn(`VapidPublicKey present: ${Boolean(VapidPublicKey)}`);
+      logger.warn(`VapidPrivateKey present: ${Boolean(VapidPrivateKey)}`);
+      logger.warn(`VapidSubject: ${VapidSubject}`);
+      return;
+    }
+
+    logger.info(`Initializing web push with VAPID subject: ${VapidSubject}`);
+    webpush.setVapidDetails(VapidSubject, VapidPublicKey, VapidPrivateKey);
+    this.isWebPushInitialized = true;
+    logger.info("Web push notifications initialized successfully");
+  }
+
+  public static async sendPushNotification(
+    request: PushNotificationRequest,
+    options: PushNotificationOptions = {},
+  ): Promise<void> {
+    logger.info(
+      `Sending push notification to ${request.deviceTokens?.length} devices`,
+    );
+
+    if (!request.deviceTokens || request.deviceTokens.length === 0) {
+      logger.error("No device tokens provided for push notification");
+      throw new Error("No device tokens provided");
+    }
+
+    if (request.deviceType !== "web") {
+      logger.error(`Unsupported device type: ${request.deviceType}`);
+      throw new Error("Only web push notifications are supported");
+    }
+
+    logger.info(
+      `Sending web push notifications to ${request.deviceTokens.length} devices`,
+    );
+    logger.info(`Notification message: ${JSON.stringify(request.message)}`);
+
+    const promises: Promise<void>[] = [];
+
+    for (const deviceToken of request.deviceTokens) {
+      promises.push(
+        this.sendWebPushNotification(deviceToken, request.message, options),
+      );
+    }
+
+    const results: Array<any> = await Promise.allSettled(promises);
+
+    let successCount: number = 0;
+    let errorCount: number = 0;
+
+    results.forEach((result: any, index: number) => {
+      if (result.status === "fulfilled") {
+        successCount++;
+        logger.info(`Device ${index + 1}: Notification sent successfully`);
+      } else {
+        errorCount++;
+        logger.error(
+          `Failed to send notification to device ${index + 1}: ${result.reason}`,
+        );
+      }
+    });
+
+    logger.info(
+      `Push notification results: ${successCount} successful, ${errorCount} failed`,
+    );
+
+    // Update user on call log timeline status if provided
+    if (options.userOnCallLogTimelineId) {
+      const status: UserNotificationStatus =
+        successCount > 0
+          ? UserNotificationStatus.Sent
+          : UserNotificationStatus.Error;
+      const statusMessage: string =
+        successCount > 0
+          ? "Push notification sent successfully"
+          : `Failed to send push notification: ${errorCount} errors`;
+
+      await UserOnCallLogTimelineService.updateOneById({
+        id: options.userOnCallLogTimelineId,
+        data: {
+          status,
+          statusMessage,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+    }
+
+    if (errorCount > 0 && successCount === 0) {
+      throw new Error(
+        `Failed to send push notification to all ${errorCount} devices`,
+      );
+    }
+  }
+
+  private static async sendWebPushNotification(
+    deviceToken: string,
+    message: PushNotificationMessage,
+    _options: PushNotificationOptions,
+  ): Promise<void> {
+    if (!this.isWebPushInitialized) {
+      this.initializeWebPush();
+    }
+
+    if (!this.isWebPushInitialized) {
+      throw new Error("Web push notifications not configured");
+    }
+
+    try {
+      const payload: string = JSON.stringify({
+        title: message.title,
+        body: message.body,
+        icon: message.icon || PushNotificationUtil.DEFAULT_ICON,
+        badge: message.badge || PushNotificationUtil.DEFAULT_BADGE,
+        data: message.data || {},
+        tag: message.tag || "oneuptime-notification",
+        requireInteraction: message.requireInteraction || false,
+        actions: message.actions || [],
+        url: message.url || message.clickAction,
+      });
+
+      logger.debug(`Sending push notification with payload: ${payload}`);
+      logger.debug(`Device token: ${deviceToken}`);
+
+      let subscriptionObject: any;
+      try {
+        subscriptionObject = JSON.parse(deviceToken);
+        logger.debug(
+          `Parsed subscription object: ${JSON.stringify(subscriptionObject)}`,
+        );
+      } catch (parseError) {
+        logger.error(`Failed to parse device token: ${parseError}`);
+        throw new Error(`Invalid device token format: ${parseError}`);
+      }
+
+      const result: webpush.SendResult = await webpush.sendNotification(
+        subscriptionObject,
+        payload,
+        {
+          TTL: 24 * 60 * 60, // 24 hours
+        },
+      );
+
+      logger.debug(`Web push notification sent successfully:`);
+      logger.debug(`Result: ${JSON.stringify(result, null, 2)}`);
+      logger.debug(`Payload: ${JSON.stringify(payload, null, 2)}`);
+      logger.debug(
+        `Subscription object: ${JSON.stringify(subscriptionObject, null, 2)}`,
+      );
+
+      logger.info(`Web push notification sent successfully`);
+    } catch (error: any) {
+      logger.error(`Failed to send web push notification: ${error.message}`);
+      logger.error(error);
+
+      // If the subscription is no longer valid, remove it
+      if (error.statusCode === 410 || error.statusCode === 404) {
+        logger.info("Removing invalid web push subscription");
+        // You would implement removal logic here
+      }
+
+      throw error;
+    }
+  }
+
+  public static async sendPushNotificationToUser(
+    userId: ObjectID,
+    projectId: ObjectID,
+    message: PushNotificationMessage,
+    options: PushNotificationOptions = {},
+  ): Promise<void> {
+    // Get all verified push devices for the user
+    const userPushDevices: UserPush[] = await UserPushService.findBy({
+      query: {
+        userId: userId,
+        projectId: projectId,
+        isVerified: true,
+      },
+      select: {
+        deviceToken: true,
+        deviceType: true,
+        _id: true,
+      },
+      limit: LIMIT_PER_PROJECT,
+      skip: 0,
+      props: {
+        isRoot: true,
+      },
+    });
+
+    if (userPushDevices.length === 0) {
+      logger.info(
+        `No verified web push devices found for user ${userId.toString()}`,
+      );
+      return;
+    }
+
+    // Get web device tokens
+    const webDevices: string[] = [];
+
+    for (const device of userPushDevices) {
+      if (device.deviceType === "web") {
+        webDevices.push(device.deviceToken!);
+      }
+    }
+
+    // Send notifications to web devices
+    if (webDevices.length > 0) {
+      await this.sendPushNotification(
+        {
+          deviceTokens: webDevices,
+          message: message,
+          deviceType: "web",
+        },
+        options,
+      );
+    }
+  }
+}

package/Server/Services/UserNotificationRuleService.ts

@@ -45,8 +45,11 @@ import AlertSeverity from "../../Models/DatabaseModels/AlertSeverity";
 import AlertSeverityService from "./AlertSeverityService";
 import WorkspaceNotificationRule from "../../Models/DatabaseModels/WorkspaceNotificationRule";
 import WorkspaceNotificationRuleService from "./WorkspaceNotificationRuleService";
+import PushNotificationService from "./PushNotificationService";
 import NotificationRuleEventType from "../../Types/Workspace/NotificationRules/EventType";
 import NotificationRuleWorkspaceChannel from "../../Types/Workspace/NotificationRules/NotificationRuleWorkspaceChannel";
+import PushNotificationUtil from "../Utils/PushNotificationUtil";
+import PushNotificationMessage from "../../Types/PushNotification/PushNotificationMessage";
 import logger from "../Utils/Logger";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 
@@ -135,6 +138,11 @@ export class Service extends DatabaseService<Model> {
           email: true,
           isVerified: true,
         },
+        userPush: {
+          deviceToken: true,
+          deviceType: true,
+          isVerified: true,
+        },
       },
       props: {
         isRoot: true,
@@ -585,6 +593,140 @@ export class Service extends DatabaseService<Model> {
         },
       });
     }
+
+    // send push notification.
+    if (
+      notificationRuleItem.userPush?.deviceToken &&
+      notificationRuleItem.userPush?.isVerified
+    ) {
+      // send push notification for alert
+      if (
+        options.userNotificationEventType ===
+          UserNotificationEventType.AlertCreated &&
+        alert
+      ) {
+        // create a log.
+        logTimelineItem.status = UserNotificationStatus.Sending;
+        logTimelineItem.statusMessage = `Sending push notification to device.`;
+        logTimelineItem.userPushId = notificationRuleItem.userPush.id!;
+
+        const updatedLog: UserOnCallLogTimeline =
+          await UserOnCallLogTimelineService.create({
+            data: logTimelineItem,
+            props: {
+              isRoot: true,
+            },
+          });
+
+        const pushMessage: PushNotificationMessage =
+          PushNotificationUtil.createAlertCreatedNotification({
+            alertTitle: alert.title!,
+            projectName: alert.project?.name || "OneUptime",
+            alertViewLink: (
+              await AlertService.getAlertLinkInDashboard(
+                alert.projectId!,
+                alert.id!,
+              )
+            ).toString(),
+          });
+
+        // send push notification.
+        PushNotificationService.sendPushNotification(
+          {
+            deviceTokens: [notificationRuleItem.userPush.deviceToken!],
+            message: pushMessage,
+            deviceType: notificationRuleItem.userPush.deviceType!,
+          },
+          {
+            projectId: options.projectId,
+            userOnCallLogTimelineId: updatedLog.id!,
+          },
+        ).catch(async (err: Error) => {
+          await UserOnCallLogTimelineService.updateOneById({
+            id: updatedLog.id!,
+            data: {
+              status: UserNotificationStatus.Error,
+              statusMessage: err.message || "Error sending push notification.",
+            },
+            props: {
+              isRoot: true,
+            },
+          });
+        });
+      }
+
+      // send push notification for incident
+      if (
+        options.userNotificationEventType ===
+          UserNotificationEventType.IncidentCreated &&
+        incident
+      ) {
+        // create a log.
+        logTimelineItem.status = UserNotificationStatus.Sending;
+        logTimelineItem.statusMessage = `Sending push notification to device.`;
+        logTimelineItem.userPushId = notificationRuleItem.userPush.id!;
+
+        const updatedLog: UserOnCallLogTimeline =
+          await UserOnCallLogTimelineService.create({
+            data: logTimelineItem,
+            props: {
+              isRoot: true,
+            },
+          });
+
+        const pushMessage: PushNotificationMessage =
+          PushNotificationUtil.createIncidentCreatedNotification({
+            incidentTitle: incident.title!,
+            projectName: incident.project?.name || "OneUptime",
+            incidentViewLink: (
+              await IncidentService.getIncidentLinkInDashboard(
+                incident.projectId!,
+                incident.id!,
+              )
+            ).toString(),
+          });
+
+        // send push notification.
+        PushNotificationService.sendPushNotification(
+          {
+            deviceTokens: [notificationRuleItem.userPush.deviceToken!],
+            message: pushMessage,
+            deviceType: notificationRuleItem.userPush.deviceType!,
+          },
+          {
+            projectId: options.projectId,
+            userOnCallLogTimelineId: updatedLog.id!,
+          },
+        ).catch(async (err: Error) => {
+          await UserOnCallLogTimelineService.updateOneById({
+            id: updatedLog.id!,
+            data: {
+              status: UserNotificationStatus.Error,
+              statusMessage: err.message || "Error sending push notification.",
+            },
+            props: {
+              isRoot: true,
+            },
+          });
+        });
+      }
+    }
+
+    if (
+      notificationRuleItem.userPush?.deviceToken &&
+      !notificationRuleItem.userPush?.isVerified
+    ) {
+      // create a log.
+      logTimelineItem.status = UserNotificationStatus.Error;
+      logTimelineItem.statusMessage = `Push notification not sent because device is not verified.`;
+
+      await UserOnCallLogTimelineService.create({
+        data: logTimelineItem,
+        props: {
+          isRoot: true,
+        },
+      });
+    }
   }
 
   @CaptureSpan()
@@ -989,9 +1131,13 @@ export class Service extends DatabaseService<Model> {
       !createBy.data.userEmail &&
       !createBy.data.userSms &&
       !createBy.data.userSmsId &&
-      !createBy.data.userEmailId
+      !createBy.data.userEmailId &&
+      !createBy.data.userPushId &&
+      !createBy.data.userPush
     ) {
-      throw new BadDataException("Call, SMS, or Email is required");
+      throw new BadDataException(
+        "Call, SMS, Email, or Push notification is required",
+      );
     }
 
     return {

package/Server/Services/UserNotificationSettingService.ts

@@ -9,6 +9,7 @@ import TeamMemberService from "./TeamMemberService";
 import UserCallService from "./UserCallService";
 import UserEmailService from "./UserEmailService";
 import UserSmsService from "./UserSmsService";
+import PushNotificationService from "./PushNotificationService";
 import { CallRequestMessage } from "../../Types/Call/CallRequest";
 import { LIMIT_PER_PROJECT } from "../../Types/Database/LimitMax";
 import { EmailEnvelope } from "../../Types/Email/EmailMessage";
@@ -17,6 +18,7 @@ import NotificationSettingEventType from "../../Types/NotificationSetting/Notifi
 import ObjectID from "../../Types/ObjectID";
 import PositiveNumber from "../../Types/PositiveNumber";
 import { SMSMessage } from "../../Types/SMS/SMS";
+import PushNotificationMessage from "../../Types/PushNotification/PushNotificationMessage";
 import UserCall from "../../Models/DatabaseModels/UserCall";
 import UserEmail from "../../Models/DatabaseModels/UserEmail";
 import UserNotificationSetting from "../../Models/DatabaseModels/UserNotificationSetting";
@@ -36,6 +38,7 @@ export class Service extends DatabaseService<UserNotificationSetting> {
     emailEnvelope: EmailEnvelope;
     smsMessage: SMSMessage;
     callRequestMessage: CallRequestMessage;
+    pushNotificationMessage: PushNotificationMessage;
   }): Promise<void> {
     if (!data.projectId) {
       throw new BadDataException(
@@ -54,6 +57,7 @@ export class Service extends DatabaseService<UserNotificationSetting> {
           alertByEmail: true,
           alertBySMS: true,
           alertByCall: true,
+          alertByPush: true,
         },
         props: {
           isRoot: true,
@@ -157,6 +161,22 @@ export class Service extends DatabaseService<UserNotificationSetting> {
           });
         }
       }
+
+      if (notificationSettings.alertByPush) {
+        logger.debug(
+          `Sending push notification to user ${data.userId.toString()} for event ${data.eventType}`,
+        );
+        PushNotificationService.sendPushNotificationToUser(
+          data.userId,
+          data.projectId,
+          data.pushNotificationMessage,
+          {
+            projectId: data.projectId,
+          },
+        ).catch((err: Error) => {
+          logger.error(err);
+        });
+      }
     }
   }
 

package/Server/Services/UserPushService.ts

@@ -0,0 +1,95 @@
+import CreateBy from "../Types/Database/CreateBy";
+import DeleteBy from "../Types/Database/DeleteBy";
+import { OnCreate, OnDelete } from "../Types/Database/Hooks";
+import DatabaseService from "./DatabaseService";
+import BadDataException from "../../Types/Exception/BadDataException";
+import PositiveNumber from "../../Types/PositiveNumber";
+import UserPush from "../../Models/DatabaseModels/UserPush";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+
+export class Service extends DatabaseService<UserPush> {
+  public constructor() {
+    super(UserPush);
+  }
+
+  @CaptureSpan()
+  protected override async onBeforeCreate(
+    createBy: CreateBy<UserPush>,
+  ): Promise<OnCreate<UserPush>> {
+    if (!createBy.data.deviceToken) {
+      throw new BadDataException("Device token is required");
+    }
+
+    if (!createBy.data.deviceType) {
+      throw new BadDataException("Device type is required");
+    }
+
+    // Validate device type
+    const validDeviceTypes: string[] = ["web", "android", "ios"];
+    if (!validDeviceTypes.includes(createBy.data.deviceType)) {
+      throw new BadDataException(
+        "Device type must be one of: " + validDeviceTypes.join(", "),
+      );
+    }
+
+    // Check if this device token already exists for this user and project
+    const existingCount: PositiveNumber = await this.countBy({
+      query: {
+        deviceToken: createBy.data.deviceToken,
+        userId: createBy.data.userId!,
+        projectId: createBy.data.projectId!,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    if (existingCount.toNumber() > 0) {
+      throw new BadDataException(
+        "This device is already registered for push notifications",
+      );
+    }
+
+    return { carryForward: null, createBy };
+  }
+
+  @CaptureSpan()
+  protected override async onBeforeDelete(
+    deleteBy: DeleteBy<UserPush>,
+  ): Promise<OnDelete<UserPush>> {
+    // Add any cleanup logic here if needed
+    return { carryForward: null, deleteBy };
+  }
+
+  @CaptureSpan()
+  public async verifyDevice(deviceId: string): Promise<void> {
+    await this.updateOneBy({
+      query: {
+        _id: deviceId,
+      },
+      data: {
+        isVerified: true,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+  }
+
+  @CaptureSpan()
+  public async unverifyDevice(deviceId: string): Promise<void> {
+    await this.updateOneBy({
+      query: {
+        _id: deviceId,
+      },
+      data: {
+        isVerified: false,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+  }
+}
+
+export default new Service();