@oneuptime/common 7.0.4346 → 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/AlertService.ts

@@ -1338,5 +1338,56 @@ ${alertSeverity.name}
 
     return alert;
   }
+
+  /**
+   * Ensures the currentAlertStateId of the alert matches the latest timeline entry.
+   */
+  public async refreshAlertCurrentStatus(alertId: ObjectID): Promise<void> {
+    const alert: Model | null = await this.findOneById({
+      id: alertId,
+      select: {
+        _id: true,
+        projectId: true,
+        currentAlertStateId: true,
+      },
+      props: { isRoot: true },
+    });
+    if (!alert || !alert.projectId) {
+      return;
+    }
+    const latestTimeline: AlertStateTimeline | null =
+      await AlertStateTimelineService.findOneBy({
+        query: {
+          alertId: alert.id!,
+          projectId: alert.projectId,
+        },
+        sort: {
+          startsAt: SortOrder.Descending,
+        },
+        select: {
+          alertStateId: true,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+    if (
+      latestTimeline &&
+      latestTimeline.alertStateId &&
+      alert.currentAlertStateId?.toString() !==
+        latestTimeline.alertStateId.toString()
+    ) {
+      await this.updateOneBy({
+        query: { _id: alert.id!.toString() },
+        data: {
+          currentAlertStateId: latestTimeline.alertStateId,
+        },
+        props: { isRoot: true },
+      });
+      logger.info(
+        `Updated Alert ${alert.id} current state to ${latestTimeline.alertStateId}`,
+      );
+    }
+  }
 }
 export default new Service();

package/Server/Services/IncidentService.ts

@@ -1932,6 +1932,59 @@ ${incidentSeverity.name}
 
     return incident.incidentNumber ? Number(incident.incidentNumber) : null;
   }
+
+  /**
+   * Ensures the currentIncidentStateId of the incident matches the latest timeline entry.
+   */
+  public async refreshIncidentCurrentStatus(
+    incidentId: ObjectID,
+  ): Promise<void> {
+    const incident: Model | null = await this.findOneById({
+      id: incidentId,
+      select: {
+        _id: true,
+        projectId: true,
+        currentIncidentStateId: true,
+      },
+      props: { isRoot: true },
+    });
+    if (!incident || !incident.projectId) {
+      return;
+    }
+    const latestTimeline: IncidentStateTimeline | null =
+      await IncidentStateTimelineService.findOneBy({
+        query: {
+          incidentId: incident.id!,
+          projectId: incident.projectId,
+        },
+        sort: {
+          startsAt: SortOrder.Descending,
+        },
+        select: {
+          incidentStateId: true,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+    if (
+      latestTimeline &&
+      latestTimeline.incidentStateId &&
+      incident.currentIncidentStateId?.toString() !==
+        latestTimeline.incidentStateId.toString()
+    ) {
+      await this.updateOneBy({
+        query: { _id: incident.id!.toString() },
+        data: {
+          currentIncidentStateId: latestTimeline.incidentStateId,
+        },
+        props: { isRoot: true },
+      });
+      logger.info(
+        `Updated Incident ${incident.id} current state to ${latestTimeline.incidentStateId}`,
+      );
+    }
+  }
 }
 
 export default new Service();

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.
 
@@ -1467,5 +1488,59 @@ ${labels
       },
     );
   }
+
+  /**
+   * Ensures the currentScheduledMaintenanceStateId of the scheduled maintenance matches the latest timeline entry.
+   */
+  public async refreshScheduledMaintenanceCurrentStatus(
+    scheduledMaintenanceId: ObjectID,
+  ): Promise<void> {
+    const scheduledMaintenance: Model | null = await this.findOneById({
+      id: scheduledMaintenanceId,
+      select: {
+        _id: true,
+        projectId: true,
+        currentScheduledMaintenanceStateId: true,
+      },
+      props: { isRoot: true },
+    });
+    if (!scheduledMaintenance || !scheduledMaintenance.projectId) {
+      return;
+    }
+    const latestTimeline: ScheduledMaintenanceStateTimeline | null =
+      await ScheduledMaintenanceStateTimelineService.findOneBy({
+        query: {
+          scheduledMaintenanceId: scheduledMaintenance.id!,
+          projectId: scheduledMaintenance.projectId,
+        },
+        sort: {
+          startsAt: SortOrder.Descending,
+        },
+        select: {
+          scheduledMaintenanceStateId: true,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+    if (
+      latestTimeline &&
+      latestTimeline.scheduledMaintenanceStateId &&
+      scheduledMaintenance.currentScheduledMaintenanceStateId?.toString() !==
+        latestTimeline.scheduledMaintenanceStateId.toString()
+    ) {
+      await this.updateOneBy({
+        query: { _id: scheduledMaintenance.id!.toString() },
+        data: {
+          currentScheduledMaintenanceStateId:
+            latestTimeline.scheduledMaintenanceStateId,
+        },
+        props: { isRoot: true },
+      });
+      logger.info(
+        `Updated ScheduledMaintenance ${scheduledMaintenance.id} current state to ${latestTimeline.scheduledMaintenanceStateId}`,
+      );
+    }
+  }
 }
 export default new Service();