@oneuptime/common 9.5.6 → 9.5.8

package/Server/Services/AlertEpisodeMemberService.ts

@@ -94,26 +94,16 @@ export class Service extends DatabaseService<Model> {
     });
 
     // Update episode's alertCount and lastAlertAddedAt
-    Promise.resolve()
-      .then(async () => {
-        try {
-          await AlertEpisodeService.updateAlertCount(
-            createdItem.alertEpisodeId!,
-          );
-          await AlertEpisodeService.updateLastAlertAddedAt(
-            createdItem.alertEpisodeId!,
-          );
-        } catch (error) {
-          logger.error(
-            `Error updating episode counts in AlertEpisodeMemberService.onCreateSuccess: ${error}`,
-          );
-        }
-      })
-      .catch((error: Error) => {
-        logger.error(
-          `Critical error in AlertEpisodeMemberService.onCreateSuccess: ${error}`,
-        );
-      });
+    try {
+      await AlertEpisodeService.updateAlertCount(createdItem.alertEpisodeId!);
+      await AlertEpisodeService.updateLastAlertAddedAt(
+        createdItem.alertEpisodeId!,
+      );
+    } catch (error) {
+      logger.error(
+        `Error updating episode counts in AlertEpisodeMemberService.onCreateSuccess: ${error}`,
+      );
+    }
 
     // Get alert details for feed
     const alert: Alert | null = await AlertService.findOneById({

package/Server/Services/AlertEpisodeService.ts

@@ -815,11 +815,12 @@ export class Service extends DatabaseService<Model> {
       },
     });
 
-    // Clear resolved timestamp
+    // Clear resolved timestamp and allAlertsResolvedAt
     await this.updateOneById({
       id: episodeId,
       data: {
-        resolvedAt: undefined as any,
+        resolvedAt: null,
+        allAlertsResolvedAt: null,
       },
       props: {
         isRoot: true,

package/Server/Services/AlertGroupingEngineService.ts

@@ -688,6 +688,7 @@ class AlertGroupingEngineServiceClass {
     newEpisode.alertGroupingRuleId = rule.id!;
     newEpisode.groupingKey = groupingKey;
     newEpisode.isManuallyCreated = false;
+    newEpisode.lastAlertAddedAt = OneUptimeDate.getCurrentDate();
 
     // Set severity from alert
     if (alert.alertSeverityId) {

package/Server/Services/IncidentEpisodeMemberService.ts

@@ -96,26 +96,18 @@ export class Service extends DatabaseService<Model> {
     });
 
     // Update episode's incidentCount and lastIncidentAddedAt
-    Promise.resolve()
-      .then(async () => {
-        try {
-          await IncidentEpisodeService.updateIncidentCount(
-            createdItem.incidentEpisodeId!,
-          );
-          await IncidentEpisodeService.updateLastIncidentAddedAt(
-            createdItem.incidentEpisodeId!,
-          );
-        } catch (error) {
-          logger.error(
-            `Error updating episode counts in IncidentEpisodeMemberService.onCreateSuccess: ${error}`,
-          );
-        }
-      })
-      .catch((error: Error) => {
-        logger.error(
-          `Critical error in IncidentEpisodeMemberService.onCreateSuccess: ${error}`,
-        );
-      });
+    try {
+      await IncidentEpisodeService.updateIncidentCount(
+        createdItem.incidentEpisodeId!,
+      );
+      await IncidentEpisodeService.updateLastIncidentAddedAt(
+        createdItem.incidentEpisodeId!,
+      );
+    } catch (error) {
+      logger.error(
+        `Error updating episode counts in IncidentEpisodeMemberService.onCreateSuccess: ${error}`,
+      );
+    }
 
     // Get incident details for feed
     const incident: Incident | null = await IncidentService.findOneById({

package/Server/Services/IncidentEpisodeService.ts

@@ -609,6 +609,18 @@ export class Service extends DatabaseService<Model> {
       },
       cascadeToIncidents: cascadeToIncidents,
     });
+
+    // Clear resolved timestamp and allIncidentsResolvedAt when episode is reopened
+    await this.updateOneById({
+      id: episodeId,
+      data: {
+        resolvedAt: null,
+        allIncidentsResolvedAt: null,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
   }
 
   @CaptureSpan()
@@ -712,15 +724,65 @@ export class Service extends DatabaseService<Model> {
       },
     });
 
-    await this.updateOneById({
+    const incidentCount: number = count.toNumber();
+
+    // Get the episode to check for templates
+    const episode: Model | null = await this.findOneById({
       id: episodeId,
-      data: {
-        incidentCount: count.toNumber(),
+      select: {
+        titleTemplate: true,
+        descriptionTemplate: true,
+        title: true,
+        description: true,
       },
       props: {
         isRoot: true,
       },
     });
+
+    const updateData: {
+      incidentCount: number;
+      title?: string;
+      description?: string;
+    } = {
+      incidentCount: incidentCount,
+    };
+
+    // Update title with dynamic variables if template exists
+    if (episode?.titleTemplate) {
+      updateData.title = this.renderTemplateWithDynamicValues(
+        episode.titleTemplate,
+        incidentCount,
+      );
+    }
+
+    // Update description with dynamic variables if template exists
+    if (episode?.descriptionTemplate) {
+      updateData.description = this.renderTemplateWithDynamicValues(
+        episode.descriptionTemplate,
+        incidentCount,
+      );
+    }
+
+    await this.updateOneById({
+      id: episodeId,
+      data: updateData,
+      props: {
+        isRoot: true,
+      },
+    });
+  }
+
+  private renderTemplateWithDynamicValues(
+    template: string,
+    incidentCount: number,
+  ): string {
+    let result: string = template;
+
+    // Replace dynamic variables
+    result = result.replace(/\{\{incidentCount\}\}/g, incidentCount.toString());
+
+    return result;
   }
 
   @CaptureSpan()

package/Server/Services/IncidentGroupingEngineService.ts

@@ -757,6 +757,7 @@ class IncidentGroupingEngineServiceClass {
     newEpisode.incidentGroupingRuleId = rule.id!;
     newEpisode.groupingKey = groupingKey;
     newEpisode.isManuallyCreated = false;
+    newEpisode.lastIncidentAddedAt = OneUptimeDate.getCurrentDate();
 
     // Set severity from incident
     if (incident.incidentSeverityId) {

package/Server/Services/Index.ts

@@ -79,6 +79,7 @@ import ProjectSmtpConfigService from "./ProjectSmtpConfigService";
 import ProjectSsoService from "./ProjectSsoService";
 import PromoCodeService from "./PromoCodeService";
 import EnterpriseLicenseService from "./EnterpriseLicenseService";
+import OpenSourceDeploymentService from "./OpenSourceDeploymentService";
 import ResellerPlanService from "./ResellerPlanService";
 import ResellerService from "./ResellerService";
 import ScheduledMaintenanceCustomFieldService from "./ScheduledMaintenanceCustomFieldService";
@@ -210,6 +211,7 @@ const services: Array<BaseService> = [
   AcmeCertificateService,
   PromoCodeService,
   EnterpriseLicenseService,
+  OpenSourceDeploymentService,
 
   ResellerService,
   ResellerPlanService,

package/Server/Services/OpenSourceDeploymentService.ts

@@ -0,0 +1,10 @@
+import DatabaseService from "./DatabaseService";
+import OpenSourceDeployment from "../../Models/DatabaseModels/OpenSourceDeployment";
+
+export class Service extends DatabaseService<OpenSourceDeployment> {
+  public constructor() {
+    super(OpenSourceDeployment);
+  }
+}
+
+export default new Service();

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(", "),