@oneuptime/common 9.5.7 → 9.5.9

package/Server/Services/IncidentEpisodeService.ts

@@ -33,6 +33,8 @@ import User from "../../Models/DatabaseModels/User";
 import { LIMIT_PER_PROJECT } from "../../Types/Database/LimitMax";
 import NotificationRuleWorkspaceChannel from "../../Types/Workspace/NotificationRules/NotificationRuleWorkspaceChannel";
 import WorkspaceType from "../../Types/Workspace/WorkspaceType";
+import IncidentEpisodeWorkspaceMessages from "../Utils/Workspace/WorkspaceMessages/IncidentEpisode";
+import { MessageBlocksByWorkspaceType } from "./WorkspaceNotificationRuleService";
 import IncidentService from "./IncidentService";
 import OnCallDutyPolicyService from "./OnCallDutyPolicyService";
 import OnCallDutyPolicy from "../../Models/DatabaseModels/OnCallDutyPolicy";
@@ -147,6 +149,17 @@ export class Service extends DatabaseService<Model> {
 
     // Create initial state timeline entry
     Promise.resolve()
+      .then(async () => {
+        try {
+          if (createdItem.projectId && createdItem.id) {
+            await this.handleEpisodeWorkspaceOperationsAsync(createdItem);
+          }
+        } catch (error) {
+          logger.error(
+            `Workspace operations failed in IncidentEpisodeService.onCreateSuccess: ${error}`,
+          );
+        }
+      })
       .then(async () => {
         try {
           await this.changeEpisodeState({
@@ -193,6 +206,51 @@ export class Service extends DatabaseService<Model> {
     return createdItem;
   }
 
+  @CaptureSpan()
+  private async handleEpisodeWorkspaceOperationsAsync(
+    createdItem: Model,
+  ): Promise<void> {
+    try {
+      if (!createdItem.projectId || !createdItem.id) {
+        throw new BadDataException(
+          "projectId and id are required for workspace operations",
+        );
+      }
+
+      const workspaceResult: {
+        channelsCreated: Array<NotificationRuleWorkspaceChannel>;
+      } | null =
+        await IncidentEpisodeWorkspaceMessages.createChannelsAndInviteUsersToChannels(
+          {
+            projectId: createdItem.projectId,
+            incidentEpisodeId: createdItem.id,
+            episodeNumber: createdItem.episodeNumber || 0,
+            ...(createdItem.episodeNumberWithPrefix
+              ? {
+                  episodeNumberWithPrefix: createdItem.episodeNumberWithPrefix,
+                }
+              : {}),
+          },
+        );
+
+      if (workspaceResult && workspaceResult.channelsCreated?.length > 0) {
+        await this.updateOneById({
+          id: createdItem.id,
+          data: {
+            postUpdatesToWorkspaceChannels:
+              workspaceResult.channelsCreated || [],
+          },
+          props: {
+            isRoot: true,
+          },
+        });
+      }
+    } catch (error) {
+      logger.error(`Error in handleEpisodeWorkspaceOperationsAsync: ${error}`);
+      throw error;
+    }
+  }
+
   @CaptureSpan()
   private async createEpisodeCreatedFeed(episode: Model): Promise<void> {
     if (!episode.id || !episode.projectId) {
@@ -213,6 +271,14 @@ export class Service extends DatabaseService<Model> {
       feedInfoInMarkdown += `This episode was manually created.\n\n`;
     }
 
+    const episodeCreateMessageBlocks: Array<MessageBlocksByWorkspaceType> =
+      await IncidentEpisodeWorkspaceMessages.getIncidentEpisodeCreateMessageBlocks(
+        {
+          incidentEpisodeId: episode.id,
+          projectId: episode.projectId,
+        },
+      );
+
     await IncidentEpisodeFeedService.createIncidentEpisodeFeedItem({
       incidentEpisodeId: episode.id,
       projectId: episode.projectId,
@@ -220,6 +286,10 @@ export class Service extends DatabaseService<Model> {
       displayColor: Red500,
       feedInfoInMarkdown: feedInfoInMarkdown,
       userId: episode.createdByUserId || undefined,
+      workspaceNotification: {
+        appendMessageBlocks: episodeCreateMessageBlocks,
+        sendWorkspaceNotification: true,
+      },
     });
   }
 
@@ -952,21 +1022,30 @@ export class Service extends DatabaseService<Model> {
   }
 
   @CaptureSpan()
-  public getWorkspaceChannelForEpisode(
-    episode: Model,
-    workspaceType: WorkspaceType,
-  ): Array<NotificationRuleWorkspaceChannel> {
-    if (
-      !episode.postUpdatesToWorkspaceChannels ||
-      !Array.isArray(episode.postUpdatesToWorkspaceChannels) ||
-      episode.postUpdatesToWorkspaceChannels.length === 0
-    ) {
-      return [];
+  public async getWorkspaceChannelForEpisode(data: {
+    episodeId: ObjectID;
+    workspaceType?: WorkspaceType | null;
+  }): Promise<Array<NotificationRuleWorkspaceChannel>> {
+    const episode: Model | null = await this.findOneById({
+      id: data.episodeId,
+      select: {
+        postUpdatesToWorkspaceChannels: true,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    if (!episode) {
+      throw new BadDataException("Incident Episode not found.");
     }
 
-    return episode.postUpdatesToWorkspaceChannels.filter(
+    return (episode.postUpdatesToWorkspaceChannels || []).filter(
       (channel: NotificationRuleWorkspaceChannel) => {
-        return channel.workspaceType === workspaceType;
+        if (!data.workspaceType) {
+          return true;
+        }
+        return channel.workspaceType === data.workspaceType;
       },
     );
   }

package/Server/Services/IncidentEpisodeStateTimelineService.ts

@@ -383,6 +383,11 @@ export class Service extends DatabaseService<IncidentEpisodeStateTimeline> {
         ? `**Cause:** \n${createdItem.rootCause}`
         : undefined,
       userId: createdItem.createdByUserId || onCreate.createBy.props.userId,
+      workspaceNotification: {
+        sendWorkspaceNotification: true,
+        notifyUserId:
+          createdItem.createdByUserId || onCreate.createBy.props.userId,
+      },
     });
 
     return createdItem;

package/Server/Services/IncidentService.ts

@@ -843,6 +843,11 @@ export class Service extends DatabaseService<Model> {
           projectId: createdItem.projectId,
           incidentId: createdItem.id,
           incidentNumber: createdItem.incidentNumber!,
+          ...(createdItem.incidentNumberWithPrefix
+            ? {
+                incidentNumberWithPrefix: createdItem.incidentNumberWithPrefix,
+              }
+            : {}),
         });
 
       if (workspaceResult && workspaceResult.channelsCreated?.length > 0) {

package/Server/Services/PushNotificationService.ts

@@ -1,5 +1,6 @@
 import PushNotificationRequest from "../../Types/PushNotification/PushNotificationRequest";
 import PushNotificationMessage from "../../Types/PushNotification/PushNotificationMessage";
+import PushDeviceType from "../../Types/PushNotification/PushDeviceType";
 import ObjectID from "../../Types/ObjectID";
 import logger from "../Utils/Logger";
 import UserPushService from "./UserPushService";
@@ -11,6 +12,7 @@ import {
   VapidSubject,
 } from "../EnvironmentConfig";
 import webpush from "web-push";
+import { Expo, ExpoPushMessage, ExpoPushTicket } from "expo-server-sdk";
 import PushNotificationUtil from "../Utils/PushNotificationUtil";
 import { LIMIT_PER_PROJECT } from "../../Types/Database/LimitMax";
 import UserPush from "../../Models/DatabaseModels/UserPush";
@@ -41,6 +43,7 @@ export interface PushNotificationOptions {
 
 export default class PushNotificationService {
   public static isWebPushInitialized = false;
+  private static expoClient: Expo = new Expo();
 
   public static initializeWebPush(): void {
     if (this.isWebPushInitialized) {
@@ -76,13 +79,8 @@ export default class PushNotificationService {
       throw new Error("No devices 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.devices.length} devices`,
+      `Sending ${request.deviceType} push notifications to ${request.devices.length} devices`,
     );
     logger.info(`Notification message: ${JSON.stringify(request.message)}`);
 
@@ -98,9 +96,25 @@ export default class PushNotificationService {
     const promises: Promise<void>[] = [];
 
     for (const device of request.devices) {
-      promises.push(
-        this.sendWebPushNotification(device.token, request.message, options),
-      );
+      if (request.deviceType === PushDeviceType.Web) {
+        promises.push(
+          this.sendWebPushNotification(device.token, request.message, options),
+        );
+      } else if (
+        request.deviceType === PushDeviceType.iOS ||
+        request.deviceType === PushDeviceType.Android
+      ) {
+        promises.push(
+          this.sendExpoPushNotification(
+            device.token,
+            request.message,
+            request.deviceType,
+            options,
+          ),
+        );
+      } else {
+        logger.error(`Unsupported device type: ${request.deviceType}`);
+      }
     }
 
     const results: Array<any> = await Promise.allSettled(promises);
@@ -314,6 +328,81 @@ export default class PushNotificationService {
     }
   }
 
+  private static async sendExpoPushNotification(
+    expoPushToken: string,
+    message: PushNotificationMessage,
+    deviceType: PushDeviceType,
+    _options: PushNotificationOptions,
+  ): Promise<void> {
+    if (!Expo.isExpoPushToken(expoPushToken)) {
+      throw new Error(
+        `Invalid Expo push token for ${deviceType} device: ${expoPushToken}`,
+      );
+    }
+
+    try {
+      const dataPayload: { [key: string]: string } = {};
+      if (message.data) {
+        for (const key of Object.keys(message.data)) {
+          dataPayload[key] = String(message.data[key]);
+        }
+      }
+      if (message.url || message.clickAction) {
+        dataPayload["url"] = message.url || message.clickAction || "";
+      }
+
+      const channelId: string =
+        deviceType === PushDeviceType.Android ? "oncall_high" : "default";
+
+      const expoPushMessage: ExpoPushMessage = {
+        to: expoPushToken,
+        title: message.title,
+        body: message.body,
+        data: dataPayload,
+        sound: "default",
+        priority: "high",
+        channelId: channelId,
+      };
+
+      const tickets: ExpoPushTicket[] =
+        await this.expoClient.sendPushNotificationsAsync([expoPushMessage]);
+
+      const ticket: ExpoPushTicket | undefined = tickets[0];
+
+      if (ticket && ticket.status === "error") {
+        const errorTicket: ExpoPushTicket & {
+          message?: string;
+          details?: { error?: string };
+        } = ticket as ExpoPushTicket & {
+          message?: string;
+          details?: { error?: string };
+        };
+        logger.error(
+          `Expo push notification error for ${deviceType} device: ${errorTicket.message}`,
+        );
+
+        if (errorTicket.details?.error === "DeviceNotRegistered") {
+          logger.info(
+            "Expo push token is no longer valid (DeviceNotRegistered)",
+          );
+        }
+
+        throw new Error(
+          `Expo push notification failed: ${errorTicket.message}`,
+        );
+      }
+
+      logger.info(
+        `Expo push notification sent successfully to ${deviceType} device`,
+      );
+    } catch (error: any) {
+      logger.error(
+        `Failed to send Expo push notification to ${deviceType} device: ${error.message}`,
+      );
+      throw error;
+    }
+  }
+
   public static async sendPushNotificationToUser(
     userId: ObjectID,
     projectId: ObjectID,
@@ -342,33 +431,46 @@ export default class PushNotificationService {
 
     if (userPushDevices.length === 0) {
       logger.info(
-        `No verified web push devices found for user ${userId.toString()}`,
+        `No verified push devices found for user ${userId.toString()}`,
       );
       return;
     }
 
-    // Get web devices with tokens and names
-    const webDevices: Array<{ token: string; name?: string }> = [];
+    // Group devices by type
+    const devicesByType: Map<
+      string,
+      Array<{ token: string; name?: string }>
+    > = new Map();
 
     for (const device of userPushDevices) {
-      if (device.deviceType === "web") {
-        webDevices.push({
-          token: device.deviceToken!,
-          name: device.deviceName || "Unknown Device",
-        });
+      const type: string = device.deviceType || PushDeviceType.Web;
+      if (!devicesByType.has(type)) {
+        devicesByType.set(type, []);
       }
+      devicesByType.get(type)!.push({
+        token: device.deviceToken!,
+        name: device.deviceName || "Unknown Device",
+      });
     }
 
-    // Send notifications to web devices
-    if (webDevices.length > 0) {
-      await this.sendPushNotification(
-        {
-          devices: webDevices,
-          message: message,
-          deviceType: "web",
-        },
-        options,
-      );
+    // Send notifications to each device type group
+    const sendPromises: Promise<void>[] = [];
+
+    for (const [deviceType, devices] of devicesByType.entries()) {
+      if (devices.length > 0) {
+        sendPromises.push(
+          this.sendPushNotification(
+            {
+              devices: devices,
+              message: message,
+              deviceType: deviceType as PushDeviceType,
+            },
+            options,
+          ),
+        );
+      }
     }
+
+    await Promise.allSettled(sendPromises);
   }
 }

package/Server/Services/UserNotificationRuleService.ts

@@ -29,6 +29,7 @@ import EmailTemplateType from "../../Types/Email/EmailTemplateType";
 import BadDataException from "../../Types/Exception/BadDataException";
 import NotificationRuleType from "../../Types/NotificationRule/NotificationRuleType";
 import ObjectID from "../../Types/ObjectID";
+import PushDeviceType from "../../Types/PushNotification/PushDeviceType";
 import Phone from "../../Types/Phone";
 import SMS from "../../Types/SMS/SMS";
 import WhatsAppMessage from "../../Types/WhatsApp/WhatsAppMessage";
@@ -1101,6 +1102,8 @@ export class Service extends DatabaseService<Model> {
             ...(alert.alertNumber !== undefined && {
               alertNumber: alert.alertNumber,
             }),
+            alertId: alert.id!.toString(),
+            projectId: alert.projectId!.toString(),
           });
 
         // send push notification.
@@ -1115,7 +1118,8 @@ export class Service extends DatabaseService<Model> {
               },
             ],
             message: pushMessage,
-            deviceType: notificationRuleItem.userPush.deviceType!,
+            deviceType: notificationRuleItem.userPush
+              .deviceType! as PushDeviceType,
           },
           {
             projectId: options.projectId,
@@ -1175,6 +1179,8 @@ export class Service extends DatabaseService<Model> {
             ...(incident.incidentNumber !== undefined && {
               incidentNumber: incident.incidentNumber,
             }),
+            incidentId: incident.id!.toString(),
+            projectId: incident.projectId!.toString(),
           });
 
         // send push notification.
@@ -1189,7 +1195,8 @@ export class Service extends DatabaseService<Model> {
               },
             ],
             message: pushMessage,
-            deviceType: notificationRuleItem.userPush.deviceType!,
+            deviceType: notificationRuleItem.userPush
+              .deviceType! as PushDeviceType,
           },
           {
             projectId: options.projectId,
@@ -1251,6 +1258,8 @@ export class Service extends DatabaseService<Model> {
             ...(alertEpisode.episodeNumberWithPrefix && {
               episodeNumberWithPrefix: alertEpisode.episodeNumberWithPrefix,
             }),
+            alertEpisodeId: alertEpisode.id!.toString(),
+            projectId: alertEpisode.projectId!.toString(),
           });
 
         PushNotificationService.sendPushNotification(
@@ -1264,7 +1273,8 @@ export class Service extends DatabaseService<Model> {
               },
             ],
             message: pushMessage,
-            deviceType: notificationRuleItem.userPush.deviceType!,
+            deviceType: notificationRuleItem.userPush
+              .deviceType! as PushDeviceType,
           },
           {
             projectId: options.projectId,

package/Server/Services/UserPushService.ts

@@ -4,6 +4,7 @@ import { OnCreate, OnDelete } from "../Types/Database/Hooks";
 import DatabaseService from "./DatabaseService";
 import BadDataException from "../../Types/Exception/BadDataException";
 import PositiveNumber from "../../Types/PositiveNumber";
+import PushDeviceType from "../../Types/PushNotification/PushDeviceType";
 import UserPush from "../../Models/DatabaseModels/UserPush";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 
@@ -25,7 +26,7 @@ export class Service extends DatabaseService<UserPush> {
     }
 
     // Validate device type
-    const validDeviceTypes: string[] = ["web", "android", "ios"];
+    const validDeviceTypes: string[] = Object.values(PushDeviceType);
     if (!validDeviceTypes.includes(createBy.data.deviceType)) {
       throw new BadDataException(
         "Device type must be one of: " + validDeviceTypes.join(", "),

package/Server/Services/WorkspaceNotificationRuleService.ts

@@ -52,6 +52,7 @@ import WorkspaceNotificationActionType from "../../Types/Workspace/WorkspaceNoti
 import ExceptionMessages from "../../Types/Exception/ExceptionMessages";
 import IncidentEpisode from "../../Models/DatabaseModels/IncidentEpisode";
 import IncidentEpisodeService from "./IncidentEpisodeService";
+import AlertEpisodeService from "./AlertEpisodeService";
 
 export interface MessageBlocksByWorkspaceType {
   workspaceType: WorkspaceType;
@@ -735,6 +736,25 @@ export class Service extends DatabaseService<WorkspaceNotificationRule> {
         );
     }
 
+    // incident episodes
+    if (data.notificationFor.incidentEpisodeId) {
+      monitorChannels =
+        await IncidentEpisodeService.getWorkspaceChannelForEpisode({
+          episodeId: data.notificationFor.incidentEpisodeId,
+          workspaceType: data.workspaceType,
+        });
+    }
+
+    // alert episodes
+    if (data.notificationFor.alertEpisodeId) {
+      monitorChannels = await AlertEpisodeService.getWorkspaceChannelForEpisode(
+        {
+          episodeId: data.notificationFor.alertEpisodeId,
+          workspaceType: data.workspaceType,
+        },
+      );
+    }
+
     logger.debug("Workspace channels found:");
     logger.debug(monitorChannels);