@oneuptime/common 7.0.4349 → 7.0.4358

package/Models/DatabaseModels/StatusPage.ts

@@ -1136,6 +1136,43 @@ export default class StatusPage extends BaseModel {
   })
   public enableSmsSubscribers?: boolean = undefined;
 
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.CreateProjectStatusPage,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadProjectStatusPage,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.EditProjectStatusPage,
+    ],
+  })
+  @TableColumn({
+    isDefaultValueColumn: true,
+    type: TableColumnType.Boolean,
+    title: "Enable Slack Subscribers",
+    description: "Can Slack subscribers subscribe to this Status Page?",
+  })
+  @Column({
+    type: ColumnType.Boolean,
+    default: false,
+  })
+  @ColumnBillingAccessControl({
+    read: PlanType.Free,
+    update: PlanType.Scale,
+    create: PlanType.Free,
+  })
+  public enableSlackSubscribers?: boolean = undefined;
+
   @ColumnAccessControl({
     create: [
       Permission.ProjectOwner,

package/Models/DatabaseModels/StatusPageSubscriber.ts

@@ -319,6 +319,66 @@ export default class StatusPageSubscriber extends BaseModel {
   })
   public subscriberWebhook?: URL = undefined;
 
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.CreateStatusPageSubscriber,
+      Permission.Public,
+    ],
+    read: [],
+    update: [],
+  })
+  @TableColumn({
+    required: false,
+    type: TableColumnType.ShortURL,
+    title: "Slack Incoming Webhook URL",
+    description:
+      "Slack incoming webhook URL to send notifications to Slack channel",
+  })
+  @Column({
+    nullable: true,
+    type: ColumnType.ShortURL,
+    transformer: URL.getDatabaseTransformer(),
+  })
+  public slackIncomingWebhookUrl?: URL = undefined;
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.CreateStatusPageSubscriber,
+      Permission.Public,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadStatusPageSubscriber,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.EditStatusPageSubscriber,
+    ],
+  })
+  @TableColumn({
+    required: false,
+    type: TableColumnType.ShortText,
+    title: "Slack Workspace Name",
+    description:
+      "Name of the Slack workspace for validation and identification",
+  })
+  @Column({
+    nullable: true,
+    type: ColumnType.ShortText,
+    length: ColumnLength.ShortText,
+  })
+  public slackWorkspaceName?: string = undefined;
+
   @ColumnAccessControl({
     create: [
       Permission.ProjectOwner,

package/Server/API/StatusPageAPI.ts

@@ -89,6 +89,7 @@ import DatabaseConfig from "../DatabaseConfig";
 import { FileRoute } from "../../ServiceRoute";
 import ProjectSmtpConfigService from "../Services/ProjectSmtpConfigService";
 import ForbiddenException from "../../Types/Exception/ForbiddenException";
+import SlackUtil from "../Utils/Workspace/Slack/Slack";
 
 export default class StatusPageAPI extends BaseAPI<
   StatusPage,
@@ -495,6 +496,7 @@ export default class StatusPageAPI extends BaseAPI<
             headerHTML: true,
             footerHTML: true,
             enableEmailSubscribers: true,
+            enableSlackSubscribers: true,
             enableSmsSubscribers: true,
             isPublicStatusPage: true,
             allowSubscribersToChooseResources: true,
@@ -2135,6 +2137,7 @@ export default class StatusPageAPI extends BaseAPI<
         _id: true,
         projectId: true,
         enableEmailSubscribers: true,
+        enableSlackSubscribers: true,
         enableSmsSubscribers: true,
         allowSubscribersToChooseResources: true,
         allowSubscribersToChooseEventTypes: true,
@@ -2173,6 +2176,18 @@ export default class StatusPageAPI extends BaseAPI<
       );
     }
 
+    if (
+      req.body.data["slackIncomingWebhookUrl"] &&
+      !statusPage.enableSlackSubscribers
+    ) {
+      logger.debug(
+        `Slack subscribers not enabled for status page with ID: ${statusPageId}`,
+      );
+      throw new BadDataException(
+        "Slack subscribers not enabled for this status page.",
+      );
+    }
+
     if (req.body.data["subscriberPhone"] && !statusPage.enableSmsSubscribers) {
       logger.debug(
         `SMS subscribers not enabled for status page with ID: ${statusPageId}`,
@@ -2186,13 +2201,14 @@ export default class StatusPageAPI extends BaseAPI<
 
     if (
       !req.body.data["subscriberEmail"] &&
-      !req.body.data["subscriberPhone"]
+      !req.body.data["subscriberPhone"] &&
+      !req.body.data["slackWorkspaceName"]
     ) {
       logger.debug(
-        `No email or phone provided for subscription to status page with ID: ${statusPageId}`,
+        `No email, slack workspace name or phone provided for subscription to status page with ID: ${statusPageId}`,
       );
       throw new BadDataException(
-        "Email or phone is required to subscribe to this status page.",
+        "Email, phone or slack workspace name is required to subscribe to this status page.",
       );
     }
 
@@ -2204,6 +2220,12 @@ export default class StatusPageAPI extends BaseAPI<
       ? new Phone(req.body.data["subscriberPhone"] as string)
       : undefined;
 
+    const slackWorkspaceName: string | undefined = req.body.data[
+      "slackWorkspaceName"
+    ]
+      ? (req.body.data["slackWorkspaceName"] as string)
+      : undefined;
+
     let statusPageSubscriber: StatusPageSubscriber | null = null;
 
     if (email) {
@@ -2240,19 +2262,39 @@ export default class StatusPageAPI extends BaseAPI<
       });
     }
 
+    if (slackWorkspaceName) {
+      logger.debug(`Setting subscriber slack workspace: ${slackWorkspaceName}`);
+      statusPageSubscriber = await StatusPageSubscriberService.findOneBy({
+        query: {
+          slackWorkspaceName: slackWorkspaceName,
+          statusPageId: statusPageId,
+        },
+        select: {
+          _id: true,
+          slackWorkspaceName: true,
+          slackIncomingWebhookUrl: true,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+    }
+
     if (!statusPageSubscriber) {
       // not found, return bad data
       logger.debug(
-        `Subscriber not found for email: ${email} or phone: ${phone}`,
+        `Subscriber not found for email: ${email}, phone: ${phone}, or slack workspace: ${slackWorkspaceName}`,
       );
 
-      let emailOrPhone: string = "email";
+      let identifierType: string = "email";
       if (phone) {
-        emailOrPhone = "phone";
+        identifierType = "phone";
+      } else if (slackWorkspaceName) {
+        identifierType = "slack workspace name";
       }
 
       throw new BadDataException(
-        `Subscription not found for this status page. Please make sure your ${emailOrPhone} is correct.`,
+        `Subscription not found for this status page. Please make sure your ${identifierType} is correct.`,
       );
     }
 
@@ -2327,6 +2369,17 @@ export default class StatusPageAPI extends BaseAPI<
         });
       }
 
+      if (statusPageSubscriber.slackIncomingWebhookUrl) {
+        const slackMessage: string = `You have selected to manage your subscription for the status page: ${statusPage.name}. You can manage your subscription here: ${manageUrlink}`;
+
+        SlackUtil.sendMessageToChannelViaIncomingWebhook({
+          url: statusPageSubscriber.slackIncomingWebhookUrl,
+          text: slackMessage,
+        }).catch((err: Error) => {
+          logger.error(err);
+        });
+      }
+
       logger.debug(
         `Subscription management link sent to subscriber with ID: ${statusPageSubscriber.id}`,
       );
@@ -2355,6 +2408,7 @@ export default class StatusPageAPI extends BaseAPI<
         projectId: true,
         enableEmailSubscribers: true,
         enableSmsSubscribers: true,
+        enableSlackSubscribers: true,
         allowSubscribersToChooseResources: true,
         allowSubscribersToChooseEventTypes: true,
         showSubscriberPageOnStatusPage: true,
@@ -2403,15 +2457,28 @@ export default class StatusPageAPI extends BaseAPI<
 
     // if no email or phone, throw error.
 
+    if (
+      req.body.data["slackWorkspaceName"] &&
+      !statusPage.enableSlackSubscribers
+    ) {
+      logger.debug(
+        `Slack subscribers not enabled for status page with ID: ${objectId}`,
+      );
+      throw new BadDataException(
+        "Slack subscribers not enabled for this status page.",
+      );
+    }
+
     if (
       !req.body.data["subscriberEmail"] &&
-      !req.body.data["subscriberPhone"]
+      !req.body.data["subscriberPhone"] &&
+      !req.body.data["slackWorkspaceName"]
     ) {
       logger.debug(
-        `No email or phone provided for subscription to status page with ID: ${objectId}`,
+        `No email, phone, or slack workspace name provided for subscription to status page with ID: ${objectId}`,
       );
       throw new BadDataException(
-        "Email or phone is required to subscribe to this status page.",
+        "Email, phone or slack workspace name is required to subscribe to this status page.",
       );
     }
 
@@ -2423,6 +2490,18 @@ export default class StatusPageAPI extends BaseAPI<
       ? new Phone(req.body.data["subscriberPhone"] as string)
       : undefined;
 
+    const slackIncomingWebhookUrl: string | undefined = req.body.data[
+      "slackIncomingWebhookUrl"
+    ]
+      ? (req.body.data["slackIncomingWebhookUrl"] as string)
+      : undefined;
+
+    const slackWorkspaceName: string | undefined = req.body.data[
+      "slackWorkspaceName"
+    ]
+      ? (req.body.data["slackWorkspaceName"] as string)
+      : undefined;
+
     let statusPageSubscriber: StatusPageSubscriber | null = null;
 
     let isUpdate: boolean = false;
@@ -2467,6 +2546,20 @@ export default class StatusPageAPI extends BaseAPI<
       statusPageSubscriber.subscriberPhone = phone;
     }
 
+    if (slackIncomingWebhookUrl) {
+      logger.debug(`Setting subscriber slack: ${slackIncomingWebhookUrl}`);
+      statusPageSubscriber.slackIncomingWebhookUrl = URL.fromString(
+        slackIncomingWebhookUrl,
+      );
+    }
+
+    if (slackWorkspaceName) {
+      logger.debug(
+        `Setting subscriber slack workspace name: ${slackWorkspaceName}`,
+      );
+      statusPageSubscriber.slackWorkspaceName = slackWorkspaceName;
+    }
+
     if (
       req.body.data["statusPageResources"] &&
       !statusPage.allowSubscribersToChooseResources
@@ -2606,6 +2699,7 @@ export default class StatusPageAPI extends BaseAPI<
           isUnsubscribed: true,
           subscriberEmail: true,
           subscriberPhone: true,
+          slackWorkspaceName: true,
           statusPageId: true,
           statusPageResources: true,
           isSubscribedToAllResources: true,

package/Server/Infrastructure/Postgres/SchemaMigrations/1749065784320-MigrationName.ts

@@ -0,0 +1,23 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class MigrationName1749065784320 implements MigrationInterface {
+  public name = "MigrationName1749065784320";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "StatusPage" ADD "enableSlackSubscribers" boolean NOT NULL DEFAULT false`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "StatusPageSubscriber" ADD "slackIncomingWebhookUrl" character varying`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "StatusPageSubscriber" DROP COLUMN "slackIncomingWebhookUrl"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "StatusPage" DROP COLUMN "enableSlackSubscribers"`,
+    );
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/1749133333893-MigrationName.ts

@@ -0,0 +1,17 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class MigrationName1749133333893 implements MigrationInterface {
+  public name = "MigrationName1749133333893";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "StatusPageSubscriber" ADD "slackWorkspaceName" character varying(100)`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "StatusPageSubscriber" DROP COLUMN "slackWorkspaceName"`,
+    );
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/Index.ts

@@ -134,6 +134,8 @@ import { MigrationName1744809770336 } from "./1744809770336-MigrationName";
 import { MigrationName1747305098533 } from "./1747305098533-MigrationName";
 import { MigrationName1747674762672 } from "./1747674762672-MigrationName";
 import { MigrationName1748456937826 } from "./1748456937826-MigrationName";
+import { MigrationName1749065784320 } from "./1749065784320-MigrationName";
+import { MigrationName1749133333893 } from "./1749133333893-MigrationName";
 
 export default [
   InitialMigration,
@@ -272,4 +274,6 @@ export default [
   MigrationName1747305098533,
   MigrationName1747674762672,
   MigrationName1748456937826,
+  MigrationName1749065784320,
+  MigrationName1749133333893,
 ];

package/Server/Services/ScheduledMaintenanceService.ts

@@ -49,6 +49,7 @@ import { IsBillingEnabled } from "../EnvironmentConfig";
 import StatusPageEventType from "../../Types/StatusPage/StatusPageEventType";
 import ScheduledMaintenanceFeedService from "./ScheduledMaintenanceFeedService";
 import { ScheduledMaintenanceFeedEventType } from "../../Models/DatabaseModels/ScheduledMaintenanceFeed";
+import SlackUtil from "../Utils/Workspace/Slack/Slack";
 import { Gray500, Red500 } from "../../Types/BrandColors";
 import Label from "../../Models/DatabaseModels/Label";
 import LabelService from "./LabelService";
@@ -254,6 +255,26 @@ export class Service extends DatabaseService<Model> {
             });
           }
 
+          if (subscriber.slackIncomingWebhookUrl) {
+            const slackMessage: string = `## 🔧 Scheduled Maintenance - ${event.title || ""}
+
+**Scheduled Date:** ${OneUptimeDate.getDateAsFormattedString(event.startsAt!)}
+
+${resourcesAffected ? `**Resources Affected:** ${resourcesAffected}` : ""}
+
+**Description:** ${event.description || ""}
+
+[View Status Page](${statusPageURL}) | [Unsubscribe](${unsubscribeUrl})`;
+
+            // send Slack notification here.
+            SlackUtil.sendMessageToChannelViaIncomingWebhook({
+              url: subscriber.slackIncomingWebhookUrl,
+              text: SlackUtil.convertMarkdownToSlackRichText(slackMessage),
+            }).catch((err: Error) => {
+              logger.error(err);
+            });
+          }
+
           if (subscriber.subscriberEmail) {
             // send email here.
 

package/Server/Services/StatusPageSubscriberService.ts

@@ -31,6 +31,7 @@ import Model from "../../Models/DatabaseModels/StatusPageSubscriber";
 import PositiveNumber from "../../Types/PositiveNumber";
 import StatusPageEventType from "../../Types/StatusPage/StatusPageEventType";
 import NumberUtil from "../../Utils/Number";
+import SlackUtil from "../Utils/Workspace/Slack/Slack";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
@@ -143,6 +144,7 @@ export class Service extends DatabaseService<Model> {
           ignoreHooks: true,
         },
       });
+
       logger.debug(`Found Subscriber by Phone: ${JSON.stringify(subscriber)}`);
     }
 
@@ -197,12 +199,28 @@ export class Service extends DatabaseService<Model> {
     if (isEmailSubscriber && !isSubscriptionConfirmed) {
       data.data.isSubscriptionConfirmed = false;
     } else {
-      data.data.isSubscriptionConfirmed = true; // if the subscriber is not email, then set it to true for SMS subscribers.
+      data.data.isSubscriptionConfirmed = true; // if the subscriber is not email, then set it to true for SMS subscribers / slack subscribers.
     }
     logger.debug(
       `Final Subscription Confirmed: ${data.data.isSubscriptionConfirmed}`,
     );
 
+    // if slack incoming webhook is provided, then see if it starts with https://hooks.slack.com/services/
+
+    if (data.data.slackIncomingWebhookUrl) {
+      logger.debug(
+        `Slack Incoming Webhook URL: ${data.data.slackIncomingWebhookUrl}`,
+      );
+      if (
+        !SlackUtil.isValidSlackIncomingWebhookUrl(
+          data.data.slackIncomingWebhookUrl,
+        )
+      ) {
+        logger.debug("Invalid Slack Incoming Webhook URL.");
+        throw new BadDataException("Invalid Slack Incoming Webhook URL.");
+      }
+    }
+
     data.data.subscriptionConfirmationToken = NumberUtil.getRandomNumber(
       100000,
       999999,
@@ -331,6 +349,38 @@ export class Service extends DatabaseService<Model> {
       }
     }
 
+    // if slack incoming webhook is provided, then send a message to the slack channel.
+    if (createdItem.slackIncomingWebhookUrl) {
+      logger.debug("Sending Slack notification for new subscriber.");
+      const slackMessage: string = `## 📢 New Subscription to ${statusPageName}
+
+**You have successfully subscribed to receive status updates!**
+
+🔗 **Status Page:** [${statusPageName}](${statusPageURL})
+📧 **Manage Subscription:** [Update preferences or unsubscribe](${unsubscribeLink})
+
+You will receive real-time notifications for:
+• Incidents and outages 
+• Scheduled maintenance events  
+• Service announcements
+• Status updates
+
+Stay informed about service availability! 🚀`;
+
+      logger.debug(`Slack Message: ${slackMessage}`);
+
+      try {
+        await SlackUtil.sendMessageToChannelViaIncomingWebhook({
+          url: URL.fromString(createdItem.slackIncomingWebhookUrl.toString()),
+          text: SlackUtil.convertMarkdownToSlackRichText(slackMessage),
+        });
+        logger.debug("Slack notification sent successfully.");
+      } catch (error) {
+        logger.error("Error sending Slack notification:");
+        logger.error(error);
+      }
+    }
+
     logger.debug("onCreateSuccess completed.");
     return createdItem;
   }
@@ -637,6 +687,7 @@ export class Service extends DatabaseService<Model> {
         subscriberEmail: true,
         subscriberPhone: true,
         subscriberWebhook: true,
+        slackIncomingWebhookUrl: true,
         isSubscribedToAllResources: true,
         statusPageResources: true,
         isSubscribedToAllEventTypes: true,
@@ -820,5 +871,69 @@ export class Service extends DatabaseService<Model> {
 
     return statusPages;
   }
+
+  @CaptureSpan()
+  public async testSlackWebhook(data: {
+    webhookUrl: string;
+    statusPageId: ObjectID;
+  }): Promise<void> {
+    // Validate the webhook URL
+    if (!data.webhookUrl.startsWith("https://hooks.slack.com/services/")) {
+      throw new BadDataException("Invalid Slack webhook URL");
+    }
+
+    // Get status page info
+    const statusPage: StatusPage | null = await StatusPageService.findOneById({
+      id: data.statusPageId,
+      props: {
+        isRoot: true,
+      },
+      select: {
+        name: true,
+        pageTitle: true,
+        projectId: true,
+        _id: true,
+      },
+    });
+
+    if (!statusPage) {
+      throw new BadDataException("Status page not found");
+    }
+
+    // Create test notification message
+    const statusPageName: string =
+      statusPage.pageTitle || statusPage.name || "Status Page";
+    const statusPageURL: string = await StatusPageService.getStatusPageURL(
+      statusPage.id!,
+    );
+
+    // Create markdown message for Slack
+    const markdownMessage: string = `## Test Notification - ${statusPageName}
+
+**This is a test notification from OneUptime.**
+
+You have successfully configured Slack notifications for this status page.
+
+You will receive real-time notifications for:
+- Incidents
+- Scheduled Maintenance Events
+- Status Updates
+- Announcements
+
+[View Status Page](${statusPageURL})`;
+
+    // Send the test notification
+    try {
+      await SlackUtil.sendMessageToChannelViaIncomingWebhook({
+        url: URL.fromString(data.webhookUrl),
+        text: SlackUtil.convertMarkdownToSlackRichText(markdownMessage),
+      });
+    } catch (error) {
+      logger.error("Error sending test Slack notification:");
+      logger.error(error);
+      throw error;
+    }
+  }
 }
+
 export default new Service();