@oneuptime/common 10.0.65 → 10.0.67

package/Server/Services/UserNotificationRuleService.ts

@@ -9,6 +9,7 @@ import IncidentSeverityService from "./IncidentSeverityService";
 import MailService from "./MailService";
 import ShortLinkService from "./ShortLinkService";
 import SmsService from "./SmsService";
+import TelegramService from "./TelegramService";
 import WhatsAppService from "./WhatsAppService";
 import UserEmailService from "./UserEmailService";
 import UserOnCallLogService from "./UserOnCallLogService";
@@ -32,6 +33,7 @@ import ObjectID from "../../Types/ObjectID";
 import PushDeviceType from "../../Types/PushNotification/PushDeviceType";
 import Phone from "../../Types/Phone";
 import SMS from "../../Types/SMS/SMS";
+import TelegramMessage from "../../Types/Telegram/TelegramMessage";
 import WhatsAppMessage from "../../Types/WhatsApp/WhatsAppMessage";
 import {
   renderWhatsAppTemplate,
@@ -74,6 +76,7 @@ export interface NotificationMethodDescriptor {
   userSmsId?: ObjectID;
   userCallId?: ObjectID;
   userWhatsAppId?: ObjectID;
+  userTelegramId?: ObjectID;
   userPushId?: ObjectID;
 }
 
@@ -165,6 +168,11 @@ export class Service extends DatabaseService<Model> {
           phone: true,
           isVerified: true,
         },
+        userTelegram: {
+          telegramChatId: true,
+          telegramUserHandle: true,
+          isVerified: true,
+        },
         userEmail: {
           email: true,
           isVerified: true,
@@ -896,6 +904,184 @@ export class Service extends DatabaseService<Model> {
       });
     }
 
+    // send Telegram.
+    if (
+      notificationRuleItem.userTelegram?.telegramChatId &&
+      notificationRuleItem.userTelegram?.isVerified
+    ) {
+      if (
+        options.userNotificationEventType ===
+          UserNotificationEventType.AlertCreated &&
+        alert
+      ) {
+        logTimelineItem.status = UserNotificationStatus.Sending;
+        logTimelineItem.statusMessage = `Sending Telegram message.`;
+        logTimelineItem.userTelegramId = notificationRuleItem.userTelegram.id!;
+
+        const updatedLog: UserOnCallLogTimeline =
+          await UserOnCallLogTimelineService.create({
+            data: logTimelineItem,
+            props: {
+              isRoot: true,
+            },
+          });
+
+        const telegramMessage: TelegramMessage = {
+          to: notificationRuleItem.userTelegram.telegramChatId,
+          body: await this.generateTelegramBodyForAlertCreated(
+            alert,
+            updatedLog.id!,
+          ),
+          parseMode: "HTML",
+          disableWebPagePreview: true,
+        };
+
+        TelegramService.sendTelegramMessage(telegramMessage, {
+          projectId: alert.projectId,
+          alertId: alert.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 Telegram message.",
+            },
+            props: {
+              isRoot: true,
+            },
+          });
+        });
+      }
+
+      if (
+        options.userNotificationEventType ===
+          UserNotificationEventType.IncidentCreated &&
+        incident
+      ) {
+        logTimelineItem.status = UserNotificationStatus.Sending;
+        logTimelineItem.statusMessage = `Sending Telegram message.`;
+        logTimelineItem.userTelegramId = notificationRuleItem.userTelegram.id!;
+
+        const updatedLog: UserOnCallLogTimeline =
+          await UserOnCallLogTimelineService.create({
+            data: logTimelineItem,
+            props: {
+              isRoot: true,
+            },
+          });
+
+        const telegramMessage: TelegramMessage = {
+          to: notificationRuleItem.userTelegram.telegramChatId,
+          body: await this.generateTelegramBodyForIncidentCreated(
+            incident,
+            updatedLog.id!,
+          ),
+          parseMode: "HTML",
+          disableWebPagePreview: true,
+        };
+
+        TelegramService.sendTelegramMessage(telegramMessage, {
+          projectId: incident.projectId,
+          incidentId: incident.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 Telegram message.",
+            },
+            props: {
+              isRoot: true,
+            },
+          });
+        });
+      }
+
+      if (
+        options.userNotificationEventType ===
+          UserNotificationEventType.AlertEpisodeCreated &&
+        alertEpisode
+      ) {
+        logTimelineItem.status = UserNotificationStatus.Sending;
+        logTimelineItem.statusMessage = `Sending Telegram message.`;
+        logTimelineItem.userTelegramId = notificationRuleItem.userTelegram.id!;
+
+        const updatedLog: UserOnCallLogTimeline =
+          await UserOnCallLogTimelineService.create({
+            data: logTimelineItem,
+            props: {
+              isRoot: true,
+            },
+          });
+
+        const telegramMessage: TelegramMessage = {
+          to: notificationRuleItem.userTelegram.telegramChatId,
+          body: await this.generateTelegramBodyForAlertEpisodeCreated(
+            alertEpisode,
+            updatedLog.id!,
+          ),
+          parseMode: "HTML",
+          disableWebPagePreview: true,
+        };
+
+        TelegramService.sendTelegramMessage(telegramMessage, {
+          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 Telegram message.",
+            },
+            props: {
+              isRoot: true,
+            },
+          });
+        });
+      }
+    }
+
+    if (
+      notificationRuleItem.userTelegram &&
+      !notificationRuleItem.userTelegram?.isVerified
+    ) {
+      logTimelineItem.status = UserNotificationStatus.Error;
+      logTimelineItem.statusMessage = `Telegram message not sent because the Telegram account is not verified.`;
+      logTimelineItem.userTelegramId = notificationRuleItem.userTelegram.id!;
+
+      await UserOnCallLogTimelineService.create({
+        data: logTimelineItem,
+        props: {
+          isRoot: true,
+        },
+      });
+    }
+
     // send call.
     if (
       notificationRuleItem.userCall?.phone &&
@@ -1680,6 +1866,161 @@ export class Service extends DatabaseService<Model> {
     return sms;
   }
 
+  private async buildOnCallAcknowledgeShortUrl(
+    userOnCallLogTimelineId: ObjectID,
+  ): Promise<URL> {
+    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()),
+      ),
+    );
+    return await ShortLinkService.getShortenedUrl(shortUrl);
+  }
+
+  /*
+   * Telegram's HTML parse_mode supports <b>, <i>, <a>, <code>. Only <, >, and &
+   * need escaping inside those tags' text content.
+   */
+  private escapeTelegramHtml(value: string): string {
+    return value
+      .replace(/&/g, "&amp;")
+      .replace(/</g, "&lt;")
+      .replace(/>/g, "&gt;");
+  }
+
+  @CaptureSpan()
+  public async generateTelegramBodyForAlertCreated(
+    alert: Alert,
+    userOnCallLogTimelineId: ObjectID,
+  ): Promise<string> {
+    const ackUrl: URL = await this.buildOnCallAcknowledgeShortUrl(
+      userOnCallLogTimelineId,
+    );
+
+    const alertIdentifier: string =
+      alert.alertNumber !== undefined
+        ? `${alert.alertNumberWithPrefix || "#" + alert.alertNumber} — ${alert.title || "Alert"}`
+        : alert.title || "Alert";
+
+    const lines: Array<string> = [
+      "🚨 <b>New alert assigned to you</b>",
+      "",
+      `📋 <b>${this.escapeTelegramHtml(alertIdentifier)}</b>`,
+      "",
+      "👤 You're getting this because you're on call.",
+    ];
+
+    if (alert.projectId && alert.id) {
+      const dashboardUrl: URL = await AlertService.getAlertLinkInDashboard(
+        alert.projectId,
+        alert.id,
+      );
+      lines.push(
+        "",
+        `🔎 <a href="${this.escapeTelegramHtml(dashboardUrl.toString())}">View alert in OneUptime</a>`,
+      );
+    }
+
+    lines.push(
+      "",
+      `✅ <a href="${this.escapeTelegramHtml(ackUrl.toString())}">Tap to acknowledge</a>`,
+    );
+
+    return lines.join("\n");
+  }
+
+  @CaptureSpan()
+  public async generateTelegramBodyForIncidentCreated(
+    incident: Incident,
+    userOnCallLogTimelineId: ObjectID,
+  ): Promise<string> {
+    const ackUrl: URL = await this.buildOnCallAcknowledgeShortUrl(
+      userOnCallLogTimelineId,
+    );
+
+    const incidentIdentifier: string =
+      incident.incidentNumber !== undefined
+        ? `${incident.incidentNumberWithPrefix || "#" + incident.incidentNumber} — ${incident.title || "Incident"}`
+        : incident.title || "Incident";
+
+    const lines: Array<string> = [
+      "🔥 <b>New incident assigned to you</b>",
+      "",
+      `📋 <b>${this.escapeTelegramHtml(incidentIdentifier)}</b>`,
+      "",
+      "👤 You're getting this because you're on call.",
+    ];
+
+    if (incident.projectId && incident.id) {
+      const dashboardUrl: URL =
+        await IncidentService.getIncidentLinkInDashboard(
+          incident.projectId,
+          incident.id,
+        );
+      lines.push(
+        "",
+        `🔎 <a href="${this.escapeTelegramHtml(dashboardUrl.toString())}">View incident in OneUptime</a>`,
+      );
+    }
+
+    lines.push(
+      "",
+      `✅ <a href="${this.escapeTelegramHtml(ackUrl.toString())}">Tap to acknowledge</a>`,
+    );
+
+    return lines.join("\n");
+  }
+
+  @CaptureSpan()
+  public async generateTelegramBodyForAlertEpisodeCreated(
+    alertEpisode: AlertEpisode,
+    userOnCallLogTimelineId: ObjectID,
+  ): Promise<string> {
+    const ackUrl: URL = await this.buildOnCallAcknowledgeShortUrl(
+      userOnCallLogTimelineId,
+    );
+
+    const episodeIdentifier: string = alertEpisode.episodeNumberWithPrefix
+      ? `${alertEpisode.episodeNumberWithPrefix} — ${alertEpisode.title || "Alert Episode"}`
+      : alertEpisode.episodeNumber !== undefined
+        ? `#${alertEpisode.episodeNumber} — ${alertEpisode.title || "Alert Episode"}`
+        : alertEpisode.title || "Alert Episode";
+
+    const lines: Array<string> = [
+      "🔔 <b>New alert episode assigned to you</b>",
+      "",
+      `📋 <b>${this.escapeTelegramHtml(episodeIdentifier)}</b>`,
+      "",
+      "👤 You're getting this because you're on call.",
+    ];
+
+    if (alertEpisode.projectId && alertEpisode.id) {
+      const dashboardUrl: URL =
+        await AlertEpisodeService.getEpisodeLinkInDashboard(
+          alertEpisode.projectId,
+          alertEpisode.id,
+        );
+      lines.push(
+        "",
+        `🔎 <a href="${this.escapeTelegramHtml(dashboardUrl.toString())}">View alert episode in OneUptime</a>`,
+      );
+    }
+
+    lines.push(
+      "",
+      `✅ <a href="${this.escapeTelegramHtml(ackUrl.toString())}">Tap to acknowledge</a>`,
+    );
+
+    return lines.join("\n");
+  }
+
   @CaptureSpan()
   public async generateWhatsAppTemplateForAlertCreated(
     to: Phone,
@@ -2288,12 +2629,14 @@ export class Service extends DatabaseService<Model> {
       !createBy.data.userSmsId &&
       !createBy.data.userWhatsApp &&
       !createBy.data.userWhatsAppId &&
+      !createBy.data.userTelegram &&
+      !createBy.data.userTelegramId &&
       !createBy.data.userEmailId &&
       !createBy.data.userPushId &&
       !createBy.data.userPush
     ) {
       throw new BadDataException(
-        "Call, SMS, WhatsApp, Email, or Push notification is required",
+        "Call, SMS, WhatsApp, Telegram, Email, or Push notification is required",
       );
     }
 
@@ -2355,6 +2698,9 @@ export class Service extends DatabaseService<Model> {
     if (descriptor.userWhatsAppId) {
       rule.userWhatsAppId = descriptor.userWhatsAppId;
     }
+    if (descriptor.userTelegramId) {
+      rule.userTelegramId = descriptor.userTelegramId;
+    }
     if (descriptor.userPushId) {
       rule.userPushId = descriptor.userPushId;
     }
@@ -2376,6 +2722,9 @@ export class Service extends DatabaseService<Model> {
     if (descriptor.userWhatsAppId) {
       query["userWhatsAppId"] = descriptor.userWhatsAppId;
     }
+    if (descriptor.userTelegramId) {
+      query["userTelegramId"] = descriptor.userTelegramId;
+    }
     if (descriptor.userPushId) {
       query["userPushId"] = descriptor.userPushId;
     }

package/Server/Services/UserNotificationSettingService.ts

@@ -6,10 +6,12 @@ import DatabaseService from "./DatabaseService";
 import MailService from "./MailService";
 import SmsService from "./SmsService";
 import TeamMemberService from "./TeamMemberService";
+import TelegramService from "./TelegramService";
 import UserCallService from "./UserCallService";
 import UserEmailService from "./UserEmailService";
 import UserSmsService from "./UserSmsService";
 import PushNotificationService from "./PushNotificationService";
+import UserTelegramService from "./UserTelegramService";
 import UserWhatsAppService from "./UserWhatsAppService";
 import WhatsAppService from "./WhatsAppService";
 import { CallRequestMessage } from "../../Types/Call/CallRequest";
@@ -21,6 +23,9 @@ import ObjectID from "../../Types/ObjectID";
 import PositiveNumber from "../../Types/PositiveNumber";
 import { SMSMessage } from "../../Types/SMS/SMS";
 import PushNotificationMessage from "../../Types/PushNotification/PushNotificationMessage";
+import TelegramMessage, {
+  TelegramMessagePayload,
+} from "../../Types/Telegram/TelegramMessage";
 import WhatsAppMessage, {
   WhatsAppMessagePayload,
 } from "../../Types/WhatsApp/WhatsAppMessage";
@@ -28,6 +33,7 @@ import UserCall from "../../Models/DatabaseModels/UserCall";
 import UserEmail from "../../Models/DatabaseModels/UserEmail";
 import UserNotificationSetting from "../../Models/DatabaseModels/UserNotificationSetting";
 import UserSMS from "../../Models/DatabaseModels/UserSMS";
+import UserTelegram from "../../Models/DatabaseModels/UserTelegram";
 import UserWhatsApp from "../../Models/DatabaseModels/UserWhatsApp";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import { appendRecipientToWhatsAppMessage } from "../Utils/WhatsAppTemplateUtil";
@@ -47,6 +53,7 @@ export class Service extends DatabaseService<UserNotificationSetting> {
     callRequestMessage: CallRequestMessage;
     pushNotificationMessage: PushNotificationMessage;
     whatsAppMessage: WhatsAppMessagePayload;
+    telegramMessage?: TelegramMessagePayload | undefined;
     incidentId?: ObjectID | undefined;
     alertId?: ObjectID | undefined;
     alertEpisodeId?: ObjectID | undefined;
@@ -79,6 +86,7 @@ export class Service extends DatabaseService<UserNotificationSetting> {
           alertByEmail: true,
           alertBySMS: true,
           alertByWhatsApp: true,
+          alertByTelegram: true,
           alertByCall: true,
           alertByPush: true,
         },
@@ -239,6 +247,112 @@ export class Service extends DatabaseService<UserNotificationSetting> {
         }
       }
 
+      if (notificationSettings.alertByTelegram) {
+        const userTelegrams: Array<UserTelegram> =
+          await UserTelegramService.findBy({
+            query: {
+              userId: data.userId,
+              projectId: data.projectId,
+              isVerified: true,
+            },
+            select: {
+              telegramChatId: true,
+            },
+            limit: LIMIT_PER_PROJECT,
+            skip: 0,
+            props: {
+              isRoot: true,
+            },
+          });
+
+        /*
+         * When the caller did not provide a Telegram-specific message we build a
+         * nicely-formatted HTML body from the email subject + SMS body + optional
+         * URL from the email envelope, with a 🔔 prefix. If they did provide one,
+         * we respect their body/parseMode verbatim.
+         */
+        const callerProvidedTelegramBody: boolean = Boolean(
+          data.telegramMessage?.body,
+        );
+
+        const escapeHtml: (value: string) => string = (
+          value: string,
+        ): string => {
+          return value
+            .replace(/&/g, "&amp;")
+            .replace(/</g, "&lt;")
+            .replace(/>/g, "&gt;");
+        };
+
+        let telegramBody: string = "";
+        let telegramParseMode: TelegramMessage["parseMode"] | undefined =
+          undefined;
+
+        if (callerProvidedTelegramBody) {
+          telegramBody = data.telegramMessage!.body;
+          telegramParseMode = data.telegramMessage!.parseMode;
+        } else {
+          const subject: string = data.emailEnvelope.subject || "";
+          const smsBody: string = data.smsMessage.message || "";
+
+          if (subject || smsBody) {
+            const lines: Array<string> = [];
+            if (subject) {
+              lines.push(`🔔 <b>${escapeHtml(subject)}</b>`);
+            } else {
+              lines.push("🔔 <b>OneUptime notification</b>");
+            }
+            if (smsBody) {
+              lines.push("");
+              lines.push(escapeHtml(smsBody));
+            }
+            telegramBody = lines.join("\n");
+            telegramParseMode = "HTML";
+          }
+        }
+
+        if (!telegramBody) {
+          logger.warn(
+            "Skipping Telegram notification because message body is empty.",
+          );
+        } else {
+          for (const userTelegram of userTelegrams) {
+            if (!userTelegram.telegramChatId) {
+              continue;
+            }
+
+            const telegramMessage: TelegramMessage = {
+              to: userTelegram.telegramChatId,
+              body: telegramBody,
+              parseMode: telegramParseMode,
+              disableWebPagePreview:
+                data.telegramMessage?.disableWebPagePreview ?? true,
+            };
+
+            TelegramService.sendTelegramMessage(telegramMessage, {
+              projectId: data.projectId,
+              incidentId: data.incidentId,
+              alertId: data.alertId,
+              alertEpisodeId: data.alertEpisodeId,
+              incidentEpisodeId: data.incidentEpisodeId,
+              monitorId: data.monitorId,
+              scheduledMaintenanceId: data.scheduledMaintenanceId,
+              statusPageId: data.statusPageId,
+              statusPageAnnouncementId: data.statusPageAnnouncementId,
+              userId: data.userId,
+              teamId: data.teamId,
+              onCallPolicyId: data.onCallPolicyId,
+              onCallPolicyEscalationRuleId: data.onCallPolicyEscalationRuleId,
+              onCallDutyPolicyExecutionLogTimelineId:
+                data.onCallDutyPolicyExecutionLogTimelineId,
+              onCallScheduleId: data.onCallScheduleId,
+            }).catch((err: Error) => {
+              logger.error(err);
+            });
+          }
+        }
+      }
+
       if (notificationSettings.alertByCall) {
         const userCalls: Array<UserCall> = await UserCallService.findBy({
           query: {