@oneuptime/common 9.2.9 → 9.2.11

package/Server/Services/ScheduledMaintenanceService.ts

@@ -59,6 +59,12 @@ import NotificationRuleWorkspaceChannel from "../../Types/Workspace/Notification
 import { MessageBlocksByWorkspaceType } from "./WorkspaceNotificationRuleService";
 import ScheduledMaintenanceWorkspaceMessages from "../Utils/Workspace/WorkspaceMessages/ScheduledMaintenance";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import StatusPageSubscriberNotificationTemplateService, {
+  Service as StatusPageSubscriberNotificationTemplateServiceClass,
+} from "./StatusPageSubscriberNotificationTemplateService";
+import StatusPageSubscriberNotificationTemplate from "../../Models/DatabaseModels/StatusPageSubscriberNotificationTemplate";
+import StatusPageSubscriberNotificationEventType from "../../Types/StatusPage/StatusPageSubscriberNotificationEventType";
+import StatusPageSubscriberNotificationMethod from "../../Types/StatusPage/StatusPageSubscriberNotificationMethod";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
@@ -209,6 +215,41 @@ export class Service extends DatabaseService<Model> {
             })
             .join(", ") || "";
 
+        // Fetch custom templates for each notification method
+        const [
+          emailTemplate,
+          smsTemplate,
+          slackTemplate,
+        ]: Array<StatusPageSubscriberNotificationTemplate | null> =
+          await Promise.all([
+            StatusPageSubscriberNotificationTemplateService.getTemplateForStatusPage(
+              {
+                statusPageId: statuspage.id!,
+                eventType:
+                  StatusPageSubscriberNotificationEventType.SubscriberScheduledMaintenanceCreated,
+                notificationMethod:
+                  StatusPageSubscriberNotificationMethod.Email,
+              },
+            ),
+            StatusPageSubscriberNotificationTemplateService.getTemplateForStatusPage(
+              {
+                statusPageId: statuspage.id!,
+                eventType:
+                  StatusPageSubscriberNotificationEventType.SubscriberScheduledMaintenanceCreated,
+                notificationMethod: StatusPageSubscriberNotificationMethod.SMS,
+              },
+            ),
+            StatusPageSubscriberNotificationTemplateService.getTemplateForStatusPage(
+              {
+                statusPageId: statuspage.id!,
+                eventType:
+                  StatusPageSubscriberNotificationEventType.SubscriberScheduledMaintenanceCreated,
+                notificationMethod:
+                  StatusPageSubscriberNotificationMethod.Slack,
+              },
+            ),
+          ]);
+
         for (const subscriber of subscribers) {
           if (!subscriber._id) {
             continue;
@@ -232,23 +273,45 @@ export class Service extends DatabaseService<Model> {
               subscriber.id!,
             ).toString();
 
-          if (subscriber.subscriberPhone) {
-            const sms: SMS = {
-              message: `
-                            Scheduled Maintenance - ${statusPageName}
-
-                            ${event.title || ""}
-
-                            ${
-                              resourcesAffected
-                                ? "Resources Affected: " + resourcesAffected
-                                : ""
-                            }
+          // Create template variables for custom templates
+          const templateVariables: Record<string, string> = {
+            statusPageName: statusPageName,
+            statusPageUrl: statusPageURL,
+            detailsUrl: scheduledEventDetailsUrl,
+            scheduledMaintenanceTitle: event.title || "",
+            scheduledMaintenanceDescription: event.description || "",
+            scheduledStartTime:
+              OneUptimeDate.getDateAsUserFriendlyFormattedString(
+                event.startsAt!,
+              ),
+            scheduledEndTime: event.endsAt
+              ? OneUptimeDate.getDateAsUserFriendlyFormattedString(event.endsAt)
+              : "",
+            resourcesAffected: resourcesAffected,
+            unsubscribeUrl: unsubscribeUrl,
+          };
 
-                            To view this event, visit ${statusPageURL}
+          if (subscriber.subscriberPhone) {
+            let smsMessage: string;
+
+            if (
+              smsTemplate &&
+              smsTemplate.templateBody &&
+              statuspage.callSmsConfig
+            ) {
+              // Use custom template only when custom Twilio is configured
+              smsMessage =
+                StatusPageSubscriberNotificationTemplateServiceClass.compileTemplate(
+                  smsTemplate.templateBody,
+                  templateVariables,
+                );
+            } else {
+              // Use default template
+              smsMessage = `Scheduled Maintenance: ${event.title || ""} on ${statusPageName}.${resourcesAffected ? ` Impact: ${resourcesAffected}.` : ""} Details: ${scheduledEventDetailsUrl}. Unsub: ${unsubscribeUrl}`;
+            }
 
-                            To update notification preferences or unsubscribe, visit ${unsubscribeUrl}
-                            `,
+            const sms: SMS = {
+              message: smsMessage,
               to: subscriber.subscriberPhone,
             };
 
@@ -266,7 +329,18 @@ export class Service extends DatabaseService<Model> {
           }
 
           if (subscriber.slackIncomingWebhookUrl) {
-            const slackMessage: string = `## 🔧 Scheduled Maintenance - ${event.title || ""}
+            let slackMessage: string;
+
+            if (slackTemplate && slackTemplate.templateBody) {
+              // Use custom template
+              slackMessage =
+                StatusPageSubscriberNotificationTemplateServiceClass.compileTemplate(
+                  slackTemplate.templateBody,
+                  templateVariables,
+                );
+            } else {
+              // Use default template
+              slackMessage = `## 🔧 Scheduled Maintenance - ${event.title || ""}
 
 **Scheduled Date:** ${OneUptimeDate.getDateAsUserFriendlyFormattedString(event.startsAt!)}
 
@@ -275,6 +349,7 @@ ${resourcesAffected ? `**Resources Affected:** ${resourcesAffected}` : ""}
 **Description:** ${event.description || ""}
 
 [View Status Page](${statusPageURL}) | [Unsubscribe](${unsubscribeUrl})`;
+            }
 
             // send Slack notification here.
             SlackUtil.sendMessageToChannelViaIncomingWebhook({
@@ -290,55 +365,101 @@ ${resourcesAffected ? `**Resources Affected:** ${resourcesAffected}` : ""}
             const statusPageIdString: string | null =
               statuspage.id?.toString() || statuspage._id?.toString() || null;
 
-            MailService.sendMail(
-              {
-                toEmail: subscriber.subscriberEmail,
-                templateType:
-                  EmailTemplateType.SubscriberScheduledMaintenanceEventCreated,
-                vars: {
-                  statusPageName: statusPageName,
-                  statusPageUrl: statusPageURL,
-                  detailsUrl: scheduledEventDetailsUrl,
-                  logoUrl:
-                    statuspage.logoFileId && statusPageIdString
-                      ? new URL(httpProtocol, host)
-                          .addRoute(StatusPageApiRoute)
-                          .addRoute(`/logo/${statusPageIdString}`)
-                          .toString()
-                      : "",
-                  isPublicStatusPage: statuspage.isPublicStatusPage
-                    ? "true"
-                    : "false",
-                  subscriberEmailNotificationFooterText:
-                    statuspage.subscriberEmailNotificationFooterText || "",
-                  resourcesAffected: resourcesAffected,
-                  scheduledAt:
-                    OneUptimeDate.getDateAsFormattedHTMLInMultipleTimezones({
-                      date: event.startsAt!,
-                      timezones: statuspage.subscriberTimezones || [],
-                      use12HourFormat: true,
-                    }),
-                  eventTitle: event.title || "",
-                  eventDescription: await Markdown.convertToHTML(
-                    event.description || "",
-                    MarkdownContentType.Email,
+            // Prepare email variables
+            const emailVars: Record<string, string> = {
+              statusPageName: statusPageName,
+              statusPageUrl: statusPageURL,
+              detailsUrl: scheduledEventDetailsUrl,
+              logoUrl:
+                statuspage.logoFileId && statusPageIdString
+                  ? new URL(httpProtocol, host)
+                      .addRoute(StatusPageApiRoute)
+                      .addRoute(`/logo/${statusPageIdString}`)
+                      .toString()
+                  : "",
+              isPublicStatusPage: statuspage.isPublicStatusPage
+                ? "true"
+                : "false",
+              subscriberEmailNotificationFooterText:
+                statuspage.subscriberEmailNotificationFooterText || "",
+              resourcesAffected: resourcesAffected,
+              scheduledAt:
+                OneUptimeDate.getDateAsFormattedHTMLInMultipleTimezones({
+                  date: event.startsAt!,
+                  timezones: statuspage.subscriberTimezones || [],
+                  use12HourFormat: true,
+                }),
+              eventTitle: event.title || "",
+              eventDescription: await Markdown.convertToHTML(
+                event.description || "",
+                MarkdownContentType.Email,
+              ),
+              unsubscribeUrl: unsubscribeUrl,
+            };
+
+            // Check for custom email template - only use when custom SMTP is configured
+            if (
+              emailTemplate &&
+              emailTemplate.templateBody &&
+              statuspage.smtpConfig
+            ) {
+              // Use custom template with BlankTemplate only when custom SMTP is configured
+              const customEmailBody: string =
+                StatusPageSubscriberNotificationTemplateServiceClass.compileTemplate(
+                  emailTemplate.templateBody,
+                  { ...templateVariables, ...emailVars },
+                );
+              const customEmailSubject: string = emailTemplate.emailSubject
+                ? StatusPageSubscriberNotificationTemplateServiceClass.compileTemplate(
+                    emailTemplate.emailSubject,
+                    { ...templateVariables, ...emailVars },
+                  )
+                : "[Scheduled Maintenance] " + (event.title || statusPageName);
+
+              MailService.sendMail(
+                {
+                  toEmail: subscriber.subscriberEmail,
+                  templateType: EmailTemplateType.BlankTemplate,
+                  vars: {
+                    body: customEmailBody,
+                  },
+                  subject: customEmailSubject,
+                },
+                {
+                  mailServer: ProjectSmtpConfigService.toEmailServer(
+                    statuspage.smtpConfig,
                   ),
-                  unsubscribeUrl: unsubscribeUrl,
+                  projectId: statuspage.projectId!,
+                  statusPageId: statuspage.id!,
+                  scheduledMaintenanceId: event.id!,
                 },
-                subject:
-                  "[Scheduled Maintenance] " + (event.title || statusPageName),
-              },
-              {
-                mailServer: ProjectSmtpConfigService.toEmailServer(
-                  statuspage.smtpConfig,
-                ),
-                projectId: statuspage.projectId!,
-                statusPageId: statuspage.id!,
-                scheduledMaintenanceId: event.id!,
-              },
-            ).catch((err: Error) => {
-              logger.error(err);
-            });
+              ).catch((err: Error) => {
+                logger.error(err);
+              });
+            } else {
+              // Use default hard-coded template
+              MailService.sendMail(
+                {
+                  toEmail: subscriber.subscriberEmail,
+                  templateType:
+                    EmailTemplateType.SubscriberScheduledMaintenanceEventCreated,
+                  vars: emailVars,
+                  subject:
+                    "[Scheduled Maintenance] " +
+                    (event.title || statusPageName),
+                },
+                {
+                  mailServer: ProjectSmtpConfigService.toEmailServer(
+                    statuspage.smtpConfig,
+                  ),
+                  projectId: statuspage.projectId!,
+                  statusPageId: statuspage.id!,
+                  scheduledMaintenanceId: event.id!,
+                },
+              ).catch((err: Error) => {
+                logger.error(err);
+              });
+            }
           }
         }
       }

package/Server/Services/StatusPageSubscriberNotificationTemplateService.ts

@@ -0,0 +1,272 @@
+import DatabaseService from "./DatabaseService";
+import Model from "../../Models/DatabaseModels/StatusPageSubscriberNotificationTemplate";
+import StatusPageSubscriberNotificationTemplateStatusPage from "../../Models/DatabaseModels/StatusPageSubscriberNotificationTemplateStatusPage";
+import ObjectID from "../../Types/ObjectID";
+import StatusPageSubscriberNotificationEventType from "../../Types/StatusPage/StatusPageSubscriberNotificationEventType";
+import StatusPageSubscriberNotificationMethod from "../../Types/StatusPage/StatusPageSubscriberNotificationMethod";
+import StatusPageSubscriberNotificationTemplateStatusPageService from "./StatusPageSubscriberNotificationTemplateStatusPageService";
+import BadDataException from "../../Types/Exception/BadDataException";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+  }
+
+  /**
+   * Get template for a specific status page, event type, and notification method.
+   * Returns null if no custom template is found (caller should use default template).
+   */
+  public async getTemplateForStatusPage(data: {
+    statusPageId: ObjectID;
+    eventType: StatusPageSubscriberNotificationEventType;
+    notificationMethod: StatusPageSubscriberNotificationMethod;
+  }): Promise<Model | null> {
+    const { statusPageId, eventType, notificationMethod } = data;
+
+    // First find the template link for this status page
+    const templateLinks: Array<StatusPageSubscriberNotificationTemplateStatusPage> =
+      await StatusPageSubscriberNotificationTemplateStatusPageService.findBy({
+        query: {
+          statusPageId: statusPageId,
+        },
+        select: {
+          statusPageSubscriberNotificationTemplateId: true,
+        },
+        skip: 0,
+        limit: 100,
+        props: {
+          isRoot: true,
+        },
+      });
+
+    if (templateLinks.length === 0) {
+      return null;
+    }
+
+    // Get the template IDs
+    const templateIds: Array<ObjectID> = templateLinks
+      .map((link: StatusPageSubscriberNotificationTemplateStatusPage) => {
+        return link.statusPageSubscriberNotificationTemplateId;
+      })
+      .filter((id: ObjectID | undefined): id is ObjectID => {
+        return id !== undefined;
+      });
+
+    if (templateIds.length === 0) {
+      return null;
+    }
+
+    // Find the specific template matching the event type and notification method
+    const templates: Array<Model> = await this.findBy({
+      query: {
+        eventType: eventType,
+        notificationMethod: notificationMethod,
+      },
+      select: {
+        _id: true,
+        templateName: true,
+        templateBody: true,
+        emailSubject: true,
+        eventType: true,
+        notificationMethod: true,
+      },
+      skip: 0,
+      limit: 100,
+      props: {
+        isRoot: true,
+      },
+    });
+
+    // Find a template that matches one of the linked template IDs
+    for (const template of templates) {
+      if (
+        templateIds.some((id: ObjectID) => {
+          return id.toString() === template._id?.toString();
+        })
+      ) {
+        return template;
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Get available variables for a specific event type.
+   * These variables can be used in templates with {{variableName}} syntax.
+   */
+  public static getAvailableVariablesForEventType(
+    eventType: StatusPageSubscriberNotificationEventType,
+  ): Array<{ name: string; description: string }> {
+    const commonVariables: Array<{ name: string; description: string }> = [
+      { name: "statusPageName", description: "Name of the status page" },
+      { name: "statusPageUrl", description: "URL of the status page" },
+      {
+        name: "unsubscribeUrl",
+        description: "URL to unsubscribe from notifications",
+      },
+      { name: "resourcesAffected", description: "List of affected resources" },
+    ];
+
+    switch (eventType) {
+      case StatusPageSubscriberNotificationEventType.SubscriberIncidentCreated:
+        return [
+          ...commonVariables,
+          { name: "incidentTitle", description: "Title of the incident" },
+          {
+            name: "incidentDescription",
+            description: "Description of the incident",
+          },
+          { name: "incidentSeverity", description: "Severity of the incident" },
+          { name: "detailsUrl", description: "URL to view incident details" },
+        ];
+
+      case StatusPageSubscriberNotificationEventType.SubscriberIncidentStateChanged:
+        return [
+          ...commonVariables,
+          { name: "incidentTitle", description: "Title of the incident" },
+          {
+            name: "incidentDescription",
+            description: "Description of the incident",
+          },
+          { name: "incidentSeverity", description: "Severity of the incident" },
+          {
+            name: "incidentState",
+            description: "Current state of the incident",
+          },
+          { name: "detailsUrl", description: "URL to view incident details" },
+        ];
+
+      case StatusPageSubscriberNotificationEventType.SubscriberIncidentNoteCreated:
+        return [
+          ...commonVariables,
+          { name: "incidentTitle", description: "Title of the incident" },
+          { name: "incidentSeverity", description: "Severity of the incident" },
+          {
+            name: "incidentState",
+            description: "Current state of the incident",
+          },
+          { name: "postedAt", description: "When the note was posted" },
+          { name: "note", description: "Content of the note" },
+          { name: "detailsUrl", description: "URL to view incident details" },
+        ];
+
+      case StatusPageSubscriberNotificationEventType.SubscriberIncidentPostmortemPublished:
+        return [
+          ...commonVariables,
+          { name: "incidentTitle", description: "Title of the incident" },
+          { name: "incidentSeverity", description: "Severity of the incident" },
+          {
+            name: "postmortemNote",
+            description: "Content of the postmortem note",
+          },
+          { name: "detailsUrl", description: "URL to view incident details" },
+        ];
+
+      case StatusPageSubscriberNotificationEventType.SubscriberAnnouncementCreated:
+        return [
+          ...commonVariables,
+          {
+            name: "announcementTitle",
+            description: "Title of the announcement",
+          },
+          {
+            name: "announcementDescription",
+            description: "Description of the announcement",
+          },
+          {
+            name: "detailsUrl",
+            description: "URL to view announcement details",
+          },
+        ];
+
+      case StatusPageSubscriberNotificationEventType.SubscriberScheduledMaintenanceCreated:
+        return [
+          ...commonVariables,
+          {
+            name: "scheduledMaintenanceTitle",
+            description: "Title of the scheduled maintenance",
+          },
+          {
+            name: "scheduledMaintenanceDescription",
+            description: "Description of the scheduled maintenance",
+          },
+          {
+            name: "scheduledStartTime",
+            description: "When the maintenance is scheduled to start",
+          },
+          {
+            name: "scheduledEndTime",
+            description: "When the maintenance is scheduled to end",
+          },
+          {
+            name: "detailsUrl",
+            description: "URL to view scheduled maintenance details",
+          },
+        ];
+
+      case StatusPageSubscriberNotificationEventType.SubscriberScheduledMaintenanceStateChanged:
+        return [
+          ...commonVariables,
+          {
+            name: "scheduledMaintenanceTitle",
+            description: "Title of the scheduled maintenance",
+          },
+          {
+            name: "scheduledMaintenanceDescription",
+            description: "Description of the scheduled maintenance",
+          },
+          {
+            name: "scheduledMaintenanceState",
+            description: "Current state of the scheduled maintenance",
+          },
+          {
+            name: "detailsUrl",
+            description: "URL to view scheduled maintenance details",
+          },
+        ];
+
+      case StatusPageSubscriberNotificationEventType.SubscriberScheduledMaintenanceNoteCreated:
+        return [
+          ...commonVariables,
+          {
+            name: "scheduledMaintenanceTitle",
+            description: "Title of the scheduled maintenance",
+          },
+          {
+            name: "scheduledMaintenanceState",
+            description: "Current state of the scheduled maintenance",
+          },
+          { name: "postedAt", description: "When the note was posted" },
+          { name: "note", description: "Content of the note" },
+          {
+            name: "detailsUrl",
+            description: "URL to view scheduled maintenance details",
+          },
+        ];
+
+      default:
+        throw new BadDataException(`Unknown event type: ${eventType}`);
+    }
+  }
+
+  /**
+   * Compile a template with the given variables.
+   * Replaces {{variableName}} with the actual values.
+   */
+  public static compileTemplate(
+    template: string,
+    variables: Record<string, string>,
+  ): string {
+    let compiledTemplate: string = template;
+
+    for (const [key, value] of Object.entries(variables)) {
+      const regex: RegExp = new RegExp(`{{\\s*${key}\\s*}}`, "g");
+      compiledTemplate = compiledTemplate.replace(regex, value || "");
+    }
+
+    return compiledTemplate;
+  }
+}
+
+export default new Service();

package/Server/Services/StatusPageSubscriberNotificationTemplateStatusPageService.ts

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

package/Server/Types/Workflow/Components/Discord/SendMessageToChannel.ts

@@ -0,0 +1,108 @@
+import ComponentCode, { RunOptions, RunReturnType } from "../../ComponentCode";
+import HTTPErrorResponse from "../../../../../Types/API/HTTPErrorResponse";
+import HTTPResponse from "../../../../../Types/API/HTTPResponse";
+import URL from "../../../../../Types/API/URL";
+import APIException from "../../../../../Types/Exception/ApiException";
+import BadDataException from "../../../../../Types/Exception/BadDataException";
+import { JSONObject } from "../../../../../Types/JSON";
+import ComponentMetadata, {
+  Port,
+} from "../../../../../Types/Workflow/Component";
+import ComponentID from "../../../../../Types/Workflow/ComponentID";
+import DiscordComponents from "../../../../../Types/Workflow/Components/Discord";
+import API from "../../../../../Utils/API";
+import CaptureSpan from "../../../../Utils/Telemetry/CaptureSpan";
+
+export default class SendMessageToChannel extends ComponentCode {
+  public constructor() {
+    super();
+
+    const Component: ComponentMetadata | undefined = DiscordComponents.find(
+      (i: ComponentMetadata) => {
+        return i.id === ComponentID.DiscordSendMessageToChannel;
+      },
+    );
+
+    if (!Component) {
+      throw new BadDataException("Component not found.");
+    }
+
+    this.setMetadata(Component);
+  }
+
+  @CaptureSpan()
+  public override async run(
+    args: JSONObject,
+    options: RunOptions,
+  ): Promise<RunReturnType> {
+    const successPort: Port | undefined = this.getMetadata().outPorts.find(
+      (p: Port) => {
+        return p.id === "success";
+      },
+    );
+
+    if (!successPort) {
+      throw options.onError(new BadDataException("Success port not found"));
+    }
+
+    const errorPort: Port | undefined = this.getMetadata().outPorts.find(
+      (p: Port) => {
+        return p.id === "error";
+      },
+    );
+
+    if (!errorPort) {
+      throw options.onError(new BadDataException("Error port not found"));
+    }
+
+    if (!args["text"]) {
+      throw options.onError(new BadDataException("Discord message not found"));
+    }
+
+    if (!args["webhook-url"]) {
+      throw options.onError(
+        new BadDataException("Discord Webhook URL not found"),
+      );
+    }
+
+    args["webhook-url"] = URL.fromString(
+      args["webhook-url"]?.toString() as string,
+    );
+
+    let apiResult: HTTPResponse<JSONObject> | HTTPErrorResponse | null = null;
+
+    try {
+      // https://discord.com/developers/docs/resources/webhook#execute-webhook
+      apiResult = await API.post({
+        url: args["webhook-url"] as URL,
+        data: {
+          content: args["text"] as string,
+        },
+      });
+
+      if (apiResult instanceof HTTPErrorResponse) {
+        return Promise.resolve({
+          returnValues: {
+            error: apiResult.message || "Server Error.",
+          },
+          executePort: errorPort,
+        });
+      }
+      return Promise.resolve({
+        returnValues: {},
+        executePort: successPort,
+      });
+    } catch (err) {
+      if (err instanceof HTTPErrorResponse) {
+        return Promise.resolve({
+          returnValues: {
+            error: err.message || "Server Error.",
+          },
+          executePort: errorPort,
+        });
+      }
+
+      throw options.onError(new APIException("Something wrong happened."));
+    }
+  }
+}