@oneuptime/common 9.4.7 → 9.4.9

package/Server/Services/UserNotificationRuleService.ts

@@ -51,6 +51,10 @@ import Alert from "../../Models/DatabaseModels/Alert";
 import AlertService from "./AlertService";
 import AlertSeverity from "../../Models/DatabaseModels/AlertSeverity";
 import AlertSeverityService from "./AlertSeverityService";
+import AlertEpisode from "../../Models/DatabaseModels/AlertEpisode";
+import AlertEpisodeService from "./AlertEpisodeService";
+import AlertEpisodeMember from "../../Models/DatabaseModels/AlertEpisodeMember";
+import AlertEpisodeMemberService from "./AlertEpisodeMemberService";
 import WorkspaceNotificationRule from "../../Models/DatabaseModels/WorkspaceNotificationRule";
 import WorkspaceNotificationRuleService from "./WorkspaceNotificationRuleService";
 import PushNotificationService from "./PushNotificationService";
@@ -73,6 +77,7 @@ export class Service extends DatabaseService<Model> {
       projectId: ObjectID;
       triggeredByIncidentId?: ObjectID | undefined;
       triggeredByAlertId?: ObjectID | undefined;
+      triggeredByAlertEpisodeId?: ObjectID | undefined;
       userNotificationEventType: UserNotificationEventType;
       onCallPolicyExecutionLogId?: ObjectID | undefined;
       onCallPolicyId: ObjectID | undefined;
@@ -201,6 +206,11 @@ export class Service extends DatabaseService<Model> {
       logTimelineItem.triggeredByAlertId = options.triggeredByAlertId;
     }
 
+    if (options.triggeredByAlertEpisodeId) {
+      logTimelineItem.triggeredByAlertEpisodeId =
+        options.triggeredByAlertEpisodeId;
+    }
+
     if (options.onCallDutyPolicyExecutionLogTimelineId) {
       logTimelineItem.onCallDutyPolicyExecutionLogTimelineId =
         options.onCallDutyPolicyExecutionLogTimelineId;
@@ -210,6 +220,7 @@ export class Service extends DatabaseService<Model> {
 
     let incident: Incident | null = null;
     let alert: Alert | null = null;
+    let alertEpisode: AlertEpisode | null = null;
 
     if (
       options.userNotificationEventType ===
@@ -270,8 +281,40 @@ export class Service extends DatabaseService<Model> {
       });
     }
 
-    if (!incident && !alert) {
-      throw new BadDataException("Incident or Alert not found.");
+    if (
+      options.userNotificationEventType ===
+        UserNotificationEventType.AlertEpisodeCreated &&
+      options.triggeredByAlertEpisodeId
+    ) {
+      alertEpisode = await AlertEpisodeService.findOneById({
+        id: options.triggeredByAlertEpisodeId!,
+        props: {
+          isRoot: true,
+        },
+        select: {
+          _id: true,
+          title: true,
+          description: true,
+          projectId: true,
+          project: {
+            name: true,
+          },
+          currentAlertState: {
+            name: true,
+          },
+          alertSeverity: {
+            name: true,
+          },
+          episodeNumber: true,
+          rootCause: true,
+        },
+      });
+    }
+
+    if (!incident && !alert && !alertEpisode) {
+      throw new BadDataException(
+        "Incident, Alert, or Alert Episode not found.",
+      );
     }
 
     if (
@@ -384,6 +427,56 @@ export class Service extends DatabaseService<Model> {
           });
         });
       }
+
+      // send email for alert episode
+      if (
+        options.userNotificationEventType ===
+          UserNotificationEventType.AlertEpisodeCreated &&
+        alertEpisode
+      ) {
+        logTimelineItem.status = UserNotificationStatus.Sending;
+        logTimelineItem.statusMessage = `Sending email to ${notificationRuleItem.userEmail?.email.toString()}`;
+        logTimelineItem.userEmailId = notificationRuleItem.userEmail.id!;
+
+        const updatedLog: UserOnCallLogTimeline =
+          await UserOnCallLogTimelineService.create({
+            data: logTimelineItem,
+            props: {
+              isRoot: true,
+            },
+          });
+
+        const emailMessage: EmailMessage =
+          await this.generateEmailTemplateForAlertEpisodeCreated(
+            notificationRuleItem.userEmail?.email,
+            alertEpisode,
+            updatedLog.id!,
+          );
+
+        MailService.sendMail(emailMessage, {
+          userOnCallLogTimelineId: updatedLog.id!,
+          projectId: options.projectId,
+          alertEpisodeId: alertEpisode.id!,
+          userId: notificationRuleItem.userId!,
+          onCallPolicyId: options.onCallPolicyId,
+          onCallPolicyEscalationRuleId: options.onCallPolicyEscalationRuleId,
+          teamId: options.userBelongsToTeamId,
+          onCallDutyPolicyExecutionLogTimelineId:
+            options.onCallDutyPolicyExecutionLogTimelineId,
+          onCallScheduleId: options.onCallScheduleId,
+        }).catch(async (err: Error) => {
+          await UserOnCallLogTimelineService.updateOneById({
+            id: updatedLog.id!,
+            data: {
+              status: UserNotificationStatus.Error,
+              statusMessage: err.message || "Error sending email.",
+            },
+            props: {
+              isRoot: true,
+            },
+          });
+        });
+      }
     }
 
     // if you have an email but is not verified, then create a log.
@@ -512,6 +605,56 @@ export class Service extends DatabaseService<Model> {
           });
         });
       }
+
+      // send sms for alert episode
+      if (
+        options.userNotificationEventType ===
+          UserNotificationEventType.AlertEpisodeCreated &&
+        alertEpisode
+      ) {
+        logTimelineItem.status = UserNotificationStatus.Sending;
+        logTimelineItem.statusMessage = `Sending SMS to ${notificationRuleItem.userSms?.phone.toString()}.`;
+        logTimelineItem.userSmsId = notificationRuleItem.userSms.id!;
+
+        const updatedLog: UserOnCallLogTimeline =
+          await UserOnCallLogTimelineService.create({
+            data: logTimelineItem,
+            props: {
+              isRoot: true,
+            },
+          });
+
+        const smsMessage: SMS =
+          await this.generateSmsTemplateForAlertEpisodeCreated(
+            notificationRuleItem.userSms.phone,
+            alertEpisode,
+            updatedLog.id!,
+          );
+
+        SmsService.sendSms(smsMessage, {
+          projectId: alertEpisode.projectId,
+          userOnCallLogTimelineId: updatedLog.id!,
+          alertEpisodeId: alertEpisode.id!,
+          userId: notificationRuleItem.userId!,
+          onCallPolicyId: options.onCallPolicyId,
+          onCallPolicyEscalationRuleId: options.onCallPolicyEscalationRuleId,
+          teamId: options.userBelongsToTeamId,
+          onCallDutyPolicyExecutionLogTimelineId:
+            options.onCallDutyPolicyExecutionLogTimelineId,
+          onCallScheduleId: options.onCallScheduleId,
+        }).catch(async (err: Error) => {
+          await UserOnCallLogTimelineService.updateOneById({
+            id: updatedLog.id!,
+            data: {
+              status: UserNotificationStatus.Error,
+              statusMessage: err.message || "Error sending SMS.",
+            },
+            props: {
+              isRoot: true,
+            },
+          });
+        });
+      }
     }
 
     if (
@@ -631,6 +774,56 @@ export class Service extends DatabaseService<Model> {
           });
         });
       }
+
+      // send WhatsApp for alert episode
+      if (
+        options.userNotificationEventType ===
+          UserNotificationEventType.AlertEpisodeCreated &&
+        alertEpisode
+      ) {
+        logTimelineItem.status = UserNotificationStatus.Sending;
+        logTimelineItem.statusMessage = `Sending WhatsApp message to ${notificationRuleItem.userWhatsApp?.phone.toString()}.`;
+        logTimelineItem.userWhatsAppId = notificationRuleItem.userWhatsApp.id!;
+
+        const updatedLog: UserOnCallLogTimeline =
+          await UserOnCallLogTimelineService.create({
+            data: logTimelineItem,
+            props: {
+              isRoot: true,
+            },
+          });
+
+        const whatsAppMessage: WhatsAppMessage =
+          await this.generateWhatsAppTemplateForAlertEpisodeCreated(
+            notificationRuleItem.userWhatsApp.phone,
+            alertEpisode,
+            updatedLog.id!,
+          );
+
+        WhatsAppService.sendWhatsAppMessage(whatsAppMessage, {
+          projectId: alertEpisode.projectId,
+          alertEpisodeId: alertEpisode.id!,
+          userOnCallLogTimelineId: updatedLog.id!,
+          userId: notificationRuleItem.userId!,
+          onCallPolicyId: options.onCallPolicyId,
+          onCallPolicyEscalationRuleId: options.onCallPolicyEscalationRuleId,
+          teamId: options.userBelongsToTeamId,
+          onCallDutyPolicyExecutionLogTimelineId:
+            options.onCallDutyPolicyExecutionLogTimelineId,
+          onCallScheduleId: options.onCallScheduleId,
+        }).catch(async (err: Error) => {
+          await UserOnCallLogTimelineService.updateOneById({
+            id: updatedLog.id!,
+            data: {
+              status: UserNotificationStatus.Error,
+              statusMessage: err.message || "Error sending WhatsApp message.",
+            },
+            props: {
+              isRoot: true,
+            },
+          });
+        });
+      }
     }
 
     if (
@@ -758,6 +951,56 @@ export class Service extends DatabaseService<Model> {
           });
         });
       }
+
+      // send call for alert episode
+      if (
+        options.userNotificationEventType ===
+          UserNotificationEventType.AlertEpisodeCreated &&
+        alertEpisode
+      ) {
+        logTimelineItem.status = UserNotificationStatus.Sending;
+        logTimelineItem.statusMessage = `Making a call to ${notificationRuleItem.userCall?.phone.toString()}.`;
+        logTimelineItem.userCallId = notificationRuleItem.userCall.id!;
+
+        const updatedLog: UserOnCallLogTimeline =
+          await UserOnCallLogTimelineService.create({
+            data: logTimelineItem,
+            props: {
+              isRoot: true,
+            },
+          });
+
+        const callRequest: CallRequest =
+          await this.generateCallTemplateForAlertEpisodeCreated(
+            notificationRuleItem.userCall?.phone,
+            alertEpisode,
+            updatedLog.id!,
+          );
+
+        CallService.makeCall(callRequest, {
+          projectId: alertEpisode.projectId,
+          userOnCallLogTimelineId: updatedLog.id!,
+          alertEpisodeId: alertEpisode.id!,
+          userId: notificationRuleItem.userId!,
+          onCallPolicyId: options.onCallPolicyId,
+          onCallPolicyEscalationRuleId: options.onCallPolicyEscalationRuleId,
+          teamId: options.userBelongsToTeamId,
+          onCallDutyPolicyExecutionLogTimelineId:
+            options.onCallDutyPolicyExecutionLogTimelineId,
+          onCallScheduleId: options.onCallScheduleId,
+        }).catch(async (err: Error) => {
+          await UserOnCallLogTimelineService.updateOneById({
+            id: updatedLog.id!,
+            data: {
+              status: UserNotificationStatus.Error,
+              statusMessage: err.message || "Error making call.",
+            },
+            props: {
+              isRoot: true,
+            },
+          });
+        });
+      }
     }
 
     if (
@@ -810,6 +1053,7 @@ export class Service extends DatabaseService<Model> {
                 alert.id!,
               )
             ).toString(),
+            alertNumber: alert.alertNumber,
           });
 
         // send push notification.
@@ -881,6 +1125,7 @@ export class Service extends DatabaseService<Model> {
                 incident.id!,
               )
             ).toString(),
+            incidentNumber: incident.incidentNumber,
           });
 
         // send push notification.
@@ -922,6 +1167,76 @@ export class Service extends DatabaseService<Model> {
           });
         });
       }
+
+      // send push notification for alert episode
+      if (
+        options.userNotificationEventType ===
+          UserNotificationEventType.AlertEpisodeCreated &&
+        alertEpisode
+      ) {
+        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.createAlertEpisodeCreatedNotification({
+            alertEpisodeTitle: alertEpisode.title!,
+            projectName: alertEpisode.project?.name || "OneUptime",
+            alertEpisodeViewLink: (
+              await AlertEpisodeService.getEpisodeLinkInDashboard(
+                alertEpisode.projectId!,
+                alertEpisode.id!,
+              )
+            ).toString(),
+            episodeNumber: alertEpisode.episodeNumber,
+          });
+
+        PushNotificationService.sendPushNotification(
+          {
+            devices: [
+              {
+                token: notificationRuleItem.userPush.deviceToken!,
+                ...(notificationRuleItem.userPush.deviceName && {
+                  name: notificationRuleItem.userPush.deviceName,
+                }),
+              },
+            ],
+            message: pushMessage,
+            deviceType: notificationRuleItem.userPush.deviceType!,
+          },
+          {
+            projectId: options.projectId,
+            userOnCallLogTimelineId: updatedLog.id!,
+            alertEpisodeId: alertEpisode.id!,
+            userId: notificationRuleItem.userId!,
+            onCallPolicyId: options.onCallPolicyId,
+            onCallPolicyEscalationRuleId: options.onCallPolicyEscalationRuleId,
+            teamId: options.userBelongsToTeamId,
+            onCallDutyPolicyExecutionLogTimelineId:
+              options.onCallDutyPolicyExecutionLogTimelineId,
+            onCallScheduleId: options.onCallScheduleId,
+          },
+        ).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 (
@@ -951,6 +1266,11 @@ export class Service extends DatabaseService<Model> {
 
     const httpProtocol: Protocol = await DatabaseConfig.getHttpProtocol();
 
+    const alertIdentifier: string =
+      alert.alertNumber !== undefined
+        ? `Alert number ${alert.alertNumber}, ${alert.title || "Alert"}`
+        : alert.title || "Alert";
+
     const callRequest: CallRequest = {
       to: to,
       data: [
@@ -961,7 +1281,7 @@ export class Service extends DatabaseService<Model> {
           sayMessage: "A new alert has been created",
         },
         {
-          sayMessage: alert.title!,
+          sayMessage: alertIdentifier,
         },
         {
           introMessage: "To acknowledge this alert press 1",
@@ -1002,6 +1322,11 @@ export class Service extends DatabaseService<Model> {
 
     const httpProtocol: Protocol = await DatabaseConfig.getHttpProtocol();
 
+    const incidentIdentifier: string =
+      incident.incidentNumber !== undefined
+        ? `Incident number ${incident.incidentNumber}, ${incident.title || "Incident"}`
+        : incident.title || "Incident";
+
     const callRequest: CallRequest = {
       to: to,
       data: [
@@ -1012,7 +1337,7 @@ export class Service extends DatabaseService<Model> {
           sayMessage: "A new incident has been created",
         },
         {
-          sayMessage: incident.title!,
+          sayMessage: incidentIdentifier,
         },
         {
           introMessage: "To acknowledge this incident press 1",
@@ -1043,6 +1368,62 @@ export class Service extends DatabaseService<Model> {
     return callRequest;
   }
 
+  @CaptureSpan()
+  public async generateCallTemplateForAlertEpisodeCreated(
+    to: Phone,
+    alertEpisode: AlertEpisode,
+    userOnCallLogTimelineId: ObjectID,
+  ): Promise<CallRequest> {
+    const host: Hostname = await DatabaseConfig.getHost();
+
+    const httpProtocol: Protocol = await DatabaseConfig.getHttpProtocol();
+
+    const episodeIdentifier: string =
+      alertEpisode.episodeNumber !== undefined
+        ? `Alert episode number ${alertEpisode.episodeNumber}, ${alertEpisode.title || "Alert Episode"}`
+        : alertEpisode.title || "Alert Episode";
+
+    const callRequest: CallRequest = {
+      to: to,
+      data: [
+        {
+          sayMessage: "This is a call from OneUptime",
+        },
+        {
+          sayMessage: "A new alert episode has been created",
+        },
+        {
+          sayMessage: episodeIdentifier,
+        },
+        {
+          introMessage: "To acknowledge this alert episode press 1",
+          numDigits: 1,
+          timeoutInSeconds: 10,
+          noInputMessage: "You have not entered any input. Good bye",
+          onInputCallRequest: {
+            "1": {
+              sayMessage: "You have acknowledged this alert episode. Good bye",
+            },
+            default: {
+              sayMessage: "Invalid input. Good bye",
+            },
+          },
+          responseUrl: new URL(
+            httpProtocol,
+            host,
+            new Route(AppApiRoute.toString())
+              .addRoute(new UserOnCallLogTimeline().crudApiPath!)
+              .addRoute(
+                "/call/gather-input/" + userOnCallLogTimelineId.toString(),
+              ),
+          ),
+        },
+      ],
+    };
+
+    return callRequest;
+  }
+
   @CaptureSpan()
   public async generateSmsTemplateForAlertCreated(
     to: Phone,
@@ -1109,6 +1490,39 @@ export class Service extends DatabaseService<Model> {
     return sms;
   }
 
+  @CaptureSpan()
+  public async generateSmsTemplateForAlertEpisodeCreated(
+    to: Phone,
+    alertEpisode: AlertEpisode,
+    userOnCallLogTimelineId: ObjectID,
+  ): Promise<SMS> {
+    const host: Hostname = await DatabaseConfig.getHost();
+    const httpProtocol: Protocol = await DatabaseConfig.getHttpProtocol();
+
+    const shortUrl: ShortLink = await ShortLinkService.saveShortLinkFor(
+      new URL(
+        httpProtocol,
+        host,
+        new Route(AppApiRoute.toString())
+          .addRoute(new UserOnCallLogTimeline().crudApiPath!)
+          .addRoute("/acknowledge-page/" + userOnCallLogTimelineId.toString()),
+      ),
+    );
+    const url: URL = await ShortLinkService.getShortenedUrl(shortUrl);
+
+    const episodeIdentifier: string =
+      alertEpisode.episodeNumber !== undefined
+        ? `#${alertEpisode.episodeNumber} (${alertEpisode.title || "Alert Episode"})`
+        : alertEpisode.title || "Alert Episode";
+
+    const sms: SMS = {
+      to,
+      message: `This is a message from OneUptime. A new alert episode has been created: ${episodeIdentifier}. To acknowledge this alert episode, please click on the following link ${url.toString()}`,
+    };
+
+    return sms;
+  }
+
   @CaptureSpan()
   public async generateWhatsAppTemplateForAlertCreated(
     to: Phone,
@@ -1223,6 +1637,65 @@ export class Service extends DatabaseService<Model> {
     };
   }
 
+  @CaptureSpan()
+  public async generateWhatsAppTemplateForAlertEpisodeCreated(
+    to: Phone,
+    alertEpisode: AlertEpisode,
+    userOnCallLogTimelineId: ObjectID,
+  ): Promise<WhatsAppMessage> {
+    const host: Hostname = await DatabaseConfig.getHost();
+    const httpProtocol: Protocol = await DatabaseConfig.getHttpProtocol();
+
+    const acknowledgeShortLink: ShortLink =
+      await ShortLinkService.saveShortLinkFor(
+        new URL(
+          httpProtocol,
+          host,
+          new Route(AppApiRoute.toString())
+            .addRoute(new UserOnCallLogTimeline().crudApiPath!)
+            .addRoute(
+              "/acknowledge-page/" + userOnCallLogTimelineId.toString(),
+            ),
+        ),
+      );
+
+    const acknowledgeUrl: URL =
+      await ShortLinkService.getShortenedUrl(acknowledgeShortLink);
+
+    const episodeLinkOnDashboard: string =
+      alertEpisode.projectId && alertEpisode.id
+        ? (
+            await AlertEpisodeService.getEpisodeLinkInDashboard(
+              alertEpisode.projectId,
+              alertEpisode.id,
+            )
+          ).toString()
+        : acknowledgeUrl.toString();
+
+    const templateKey: WhatsAppTemplateId =
+      WhatsAppTemplateIds.AlertEpisodeCreated;
+    const templateVariables: Record<string, string> = {
+      project_name: alertEpisode.project?.name || "OneUptime",
+      episode_title: alertEpisode.title || "",
+      acknowledge_url: acknowledgeUrl.toString(),
+      episode_number:
+        alertEpisode.episodeNumber !== undefined
+          ? alertEpisode.episodeNumber.toString()
+          : "",
+      episode_link: episodeLinkOnDashboard,
+    };
+
+    const body: string = renderWhatsAppTemplate(templateKey, templateVariables);
+
+    return {
+      to,
+      body,
+      templateKey,
+      templateVariables,
+      templateLanguageCode: WhatsAppTemplateLanguage[templateKey],
+    };
+  }
+
   @CaptureSpan()
   public async generateEmailTemplateForAlertCreated(
     to: Email,
@@ -1232,8 +1705,13 @@ export class Service extends DatabaseService<Model> {
     const host: Hostname = await DatabaseConfig.getHost();
     const httpProtocol: Protocol = await DatabaseConfig.getHttpProtocol();
 
+    const alertNumber: string = alert.alertNumber
+      ? `#${alert.alertNumber}`
+      : "";
+
     const vars: Dictionary<string> = {
       alertTitle: alert.title!,
+      alertNumber: alertNumber,
       projectName: alert.project!.name!,
       currentState: alert.currentAlertState!.name!,
       alertDescription: await Markdown.convertToHTML(
@@ -1257,7 +1735,7 @@ export class Service extends DatabaseService<Model> {
       toEmail: to!,
       templateType: EmailTemplateType.AcknowledgeAlert,
       vars: vars,
-      subject: "ACTION REQUIRED: Alert created - " + alert.title!,
+      subject: `ACTION REQUIRED: Alert ${alertNumber} created - ${alert.title!}`,
     };
 
     return emailMessage;
@@ -1272,8 +1750,13 @@ export class Service extends DatabaseService<Model> {
     const host: Hostname = await DatabaseConfig.getHost();
     const httpProtocol: Protocol = await DatabaseConfig.getHttpProtocol();
 
+    const incidentNumber: string = incident.incidentNumber
+      ? `#${incident.incidentNumber}`
+      : "";
+
     const vars: Dictionary<string> = {
       incidentTitle: incident.title!,
+      incidentNumber: incidentNumber,
       projectName: incident.project!.name!,
       currentState: incident.currentIncidentState!.name!,
       incidentDescription: await Markdown.convertToHTML(
@@ -1302,7 +1785,148 @@ export class Service extends DatabaseService<Model> {
       toEmail: to!,
       templateType: EmailTemplateType.AcknowledgeIncident,
       vars: vars,
-      subject: "ACTION REQUIRED: Incident created - " + incident.title!,
+      subject: `ACTION REQUIRED: Incident ${incidentNumber} created - ${incident.title!}`,
+    };
+
+    return emailMessage;
+  }
+
+  @CaptureSpan()
+  public async generateEmailTemplateForAlertEpisodeCreated(
+    to: Email,
+    alertEpisode: AlertEpisode,
+    userOnCallLogTimelineId: ObjectID,
+  ): Promise<EmailMessage> {
+    const host: Hostname = await DatabaseConfig.getHost();
+    const httpProtocol: Protocol = await DatabaseConfig.getHttpProtocol();
+
+    // Fetch alerts that are members of this episode
+    const episodeMembers: Array<AlertEpisodeMember> =
+      await AlertEpisodeMemberService.findBy({
+        query: {
+          alertEpisodeId: alertEpisode.id!,
+        },
+        select: {
+          alertId: true,
+          alert: {
+            _id: true,
+            title: true,
+            alertNumber: true,
+            monitor: {
+              _id: true,
+              name: true,
+            },
+          },
+        },
+        props: {
+          isRoot: true,
+        },
+        limit: LIMIT_PER_PROJECT,
+        skip: 0,
+      });
+
+    // Get unique monitors (resources affected)
+    const monitorNames: Set<string> = new Set();
+    for (const member of episodeMembers) {
+      if (member.alert?.monitor?.name) {
+        monitorNames.add(member.alert.monitor.name);
+      }
+    }
+
+    const resourcesAffected: string =
+      monitorNames.size > 0
+        ? Array.from(monitorNames).join(", ")
+        : "No resources identified";
+
+    // Build alerts list HTML with proper email styling
+    let alertsListHtml: string = "";
+    if (episodeMembers.length > 0) {
+      const alertRows: string[] = [];
+      for (const member of episodeMembers) {
+        if (member.alert) {
+          const alertTitle: string = member.alert.title || "Untitled Alert";
+          const alertNumber: string = member.alert.alertNumber
+            ? `#${member.alert.alertNumber}`
+            : "";
+          const alertLink: string = (
+            await AlertService.getAlertLinkInDashboard(
+              alertEpisode.projectId!,
+              new ObjectID(member.alert._id as string),
+            )
+          ).toString();
+          const monitorName: string = member.alert.monitor?.name || "";
+
+          alertRows.push(`
+            <tr>
+              <td style="padding: 12px 16px; border-bottom: 1px solid #e2e8f0;">
+                <table cellpadding="0" cellspacing="0" width="100%">
+                  <tr>
+                    <td style="vertical-align: middle;">
+                      <span style="display: inline-block; background-color: #dbeafe; color: #1e40af; font-size: 12px; font-weight: 600; padding: 2px 8px; border-radius: 4px; margin-right: 8px;">${alertNumber}</span>
+                      <a href="${alertLink}" style="color: #2563eb; font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; font-size: 14px; font-weight: 500; text-decoration: none;">${alertTitle}</a>
+                      ${monitorName ? `<span style="display: block; color: #64748b; font-size: 12px; margin-top: 4px;">Monitor: ${monitorName}</span>` : ""}
+                    </td>
+                    <td style="text-align: right; vertical-align: middle;">
+                      <a href="${alertLink}" style="color: #2563eb; font-size: 12px; text-decoration: none;">View →</a>
+                    </td>
+                  </tr>
+                </table>
+              </td>
+            </tr>
+          `);
+        }
+      }
+      if (alertRows.length > 0) {
+        alertsListHtml = `
+          <table cellpadding="0" cellspacing="0" width="100%" style="background: linear-gradient(135deg, #f8fafc 0%, #f1f5f9 100%); border-radius: 8px; border: 1px solid #e2e8f0; margin: 8px 0 16px 0;">
+            <tbody>
+              ${alertRows.join("")}
+            </tbody>
+          </table>
+        `;
+      }
+    }
+
+    const episodeNumber: string = alertEpisode.episodeNumber
+      ? `#${alertEpisode.episodeNumber}`
+      : "";
+
+    const vars: Dictionary<string> = {
+      alertEpisodeTitle: alertEpisode.title!,
+      episodeNumber: episodeNumber,
+      projectName: alertEpisode.project!.name!,
+      currentState: alertEpisode.currentAlertState!.name!,
+      alertEpisodeDescription: await Markdown.convertToHTML(
+        alertEpisode.description! || "",
+        MarkdownContentType.Email,
+      ),
+      alertEpisodeSeverity: alertEpisode.alertSeverity!.name!,
+      resourcesAffected: resourcesAffected,
+      rootCause:
+        alertEpisode.rootCause ||
+        "No root cause identified for this alert episode",
+      alertsList: alertsListHtml,
+      alertsCount: episodeMembers.length.toString(),
+      alertEpisodeViewLink: (
+        await AlertEpisodeService.getEpisodeLinkInDashboard(
+          alertEpisode.projectId!,
+          alertEpisode.id!,
+        )
+      ).toString(),
+      acknowledgeAlertEpisodeLink: new URL(
+        httpProtocol,
+        host,
+        new Route(AppApiRoute.toString())
+          .addRoute(new UserOnCallLogTimeline().crudApiPath!)
+          .addRoute("/acknowledge-page/" + userOnCallLogTimelineId.toString()),
+      ).toString(),
+    };
+
+    const emailMessage: EmailMessage = {
+      toEmail: to!,
+      templateType: EmailTemplateType.AcknowledgeAlertEpisode,
+      vars: vars,
+      subject: `ACTION REQUIRED: Alert Episode ${episodeNumber} created - ${alertEpisode.title!}`,
     };
 
     return emailMessage;
@@ -1315,6 +1939,7 @@ export class Service extends DatabaseService<Model> {
       projectId: ObjectID;
       triggeredByIncidentId?: ObjectID | undefined;
       triggeredByAlertId?: ObjectID | undefined;
+      triggeredByAlertEpisodeId?: ObjectID | undefined;
       userNotificationEventType: UserNotificationEventType;
       onCallPolicyExecutionLogId?: ObjectID | undefined;
       onCallPolicyId: ObjectID | undefined;
@@ -1339,6 +1964,11 @@ export class Service extends DatabaseService<Model> {
       userOnCallLog.triggeredByAlertId = options.triggeredByAlertId;
     }
 
+    if (options.triggeredByAlertEpisodeId) {
+      userOnCallLog.triggeredByAlertEpisodeId =
+        options.triggeredByAlertEpisodeId;
+    }
+
     userOnCallLog.userNotificationEventType = options.userNotificationEventType;
 
     if (options.onCallPolicyExecutionLogId) {
@@ -1512,7 +2142,7 @@ export class Service extends DatabaseService<Model> {
           userId,
           userEmailId: userEmail.id!,
           incidentSeverityId: incidentSeverity.id!,
-          ruleType: NotificationRuleType.ON_CALL_EXECUTED,
+          ruleType: NotificationRuleType.ON_CALL_EXECUTED_INCIDENT,
         },
         props: {
           isRoot: true,
@@ -1530,7 +2160,8 @@ export class Service extends DatabaseService<Model> {
       notificationRule.userEmailId = userEmail.id!;
       notificationRule.incidentSeverityId = incidentSeverity.id!;
       notificationRule.notifyAfterMinutes = 0;
-      notificationRule.ruleType = NotificationRuleType.ON_CALL_EXECUTED;
+      notificationRule.ruleType =
+        NotificationRuleType.ON_CALL_EXECUTED_INCIDENT;
 
       await this.create({
         data: notificationRule,
@@ -1573,7 +2204,7 @@ export class Service extends DatabaseService<Model> {
           userId,
           userEmailId: userEmail.id!,
           alertSeverityId: alertSeverity.id!,
-          ruleType: NotificationRuleType.ON_CALL_EXECUTED,
+          ruleType: NotificationRuleType.ON_CALL_EXECUTED_ALERT,
         },
         props: {
           isRoot: true,
@@ -1591,7 +2222,7 @@ export class Service extends DatabaseService<Model> {
       notificationRule.userEmailId = userEmail.id!;
       notificationRule.alertSeverityId = alertSeverity.id!;
       notificationRule.notifyAfterMinutes = 0;
-      notificationRule.ruleType = NotificationRuleType.ON_CALL_EXECUTED;
+      notificationRule.ruleType = NotificationRuleType.ON_CALL_EXECUTED_ALERT;
 
       await this.create({
         data: notificationRule,