@oneuptime/common 7.0.3652 → 7.0.3655

package/Models/DatabaseModels/Alert.ts

@@ -1035,4 +1035,23 @@ export default class Alert extends BaseModel {
     nullable: true,
   })
   public alertNumber?: number = undefined;
+
+  @ColumnAccessControl({
+    create: [],
+    read: [],
+    update: [],
+  })
+  @TableColumn({
+    isDefaultValueColumn: false,
+    required: false,
+    type: TableColumnType.ShortText,
+    title: "Post Updates To Slack Channel ID",
+    description: "Post Updates To Slack Channel ID",
+  })
+  @Column({
+    type: ColumnType.ShortText,
+    length: ColumnLength.ShortText,
+    nullable: true,
+  })
+  public postUpdatesToSlackChannelId?: number = undefined;
 }

package/Models/DatabaseModels/Incident.ts

@@ -1120,4 +1120,23 @@ export default class Incident extends BaseModel {
     nullable: true,
   })
   public incidentNumber?: number = undefined;
+
+  @ColumnAccessControl({
+    create: [],
+    read: [],
+    update: [],
+  })
+  @TableColumn({
+    isDefaultValueColumn: false,
+    required: false,
+    type: TableColumnType.ShortText,
+    title: "Post Updates To Slack Channel ID",
+    description: "Post Updates To Slack Channel ID",
+  })
+  @Column({
+    type: ColumnType.ShortText,
+    length: ColumnLength.ShortText,
+    nullable: true,
+  })
+  public postUpdatesToSlackChannelId?: number = undefined;
 }

package/Models/DatabaseModels/ScheduledMaintenance.ts

@@ -979,4 +979,23 @@ export default class ScheduledMaintenance extends BaseModel {
     nullable: true,
   })
   public scheduledMaintenanceNumber?: number = undefined;
+
+  @ColumnAccessControl({
+    create: [],
+    read: [],
+    update: [],
+  })
+  @TableColumn({
+    isDefaultValueColumn: false,
+    required: false,
+    type: TableColumnType.ShortText,
+    title: "Post Updates To Slack Channel ID",
+    description: "Post Updates To Slack Channel ID",
+  })
+  @Column({
+    type: ColumnType.ShortText,
+    length: ColumnLength.ShortText,
+    nullable: true,
+  })
+  public postUpdatesToSlackChannelId?: number = undefined;
 }

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

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

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

@@ -102,6 +102,7 @@ import { MigrationName1737997557974 } from "./1737997557974-MigrationName";
 import { MigrationName1739209832500 } from "./1739209832500-MigrationName";
 import { MigrationName1739210586538 } from "./1739210586538-MigrationName";
 import { MigrationName1739217257089 } from "./1739217257089-MigrationName";
+import { MigrationName1739282331053 } from "./1739282331053-MigrationName";
 
 export default [
   InitialMigration,
@@ -208,4 +209,5 @@ export default [
   MigrationName1739209832500,
   MigrationName1739210586538,
   MigrationName1739217257089,
+  MigrationName1739282331053,
 ];

package/Server/Services/ProjectService.ts

@@ -465,7 +465,7 @@ export class ProjectService extends DatabaseService<Model> {
 `;
       }
 
-      SlackUtil.sendMessageToChannel({
+      SlackUtil.sendMessageToChannelViaIncomingWebhook({
         url: URL.fromString(NotificationSlackWebhookOnSubscriptionUpdate),
         text: slackMessage,
       }).catch((error: Exception) => {
@@ -668,7 +668,7 @@ export class ProjectService extends DatabaseService<Model> {
 `;
         }
 
-        SlackUtil.sendMessageToChannel({
+        SlackUtil.sendMessageToChannelViaIncomingWebhook({
           url: URL.fromString(NotificationSlackWebhookOnCreateProject),
           text: slackMessage,
         }).catch((error: Exception) => {
@@ -1178,7 +1178,7 @@ export class ProjectService extends DatabaseService<Model> {
 `;
         }
 
-        SlackUtil.sendMessageToChannel({
+        SlackUtil.sendMessageToChannelViaIncomingWebhook({
           url: URL.fromString(NotificationSlackWebhookOnDeleteProject),
           text: slackMessage,
         }).catch((err: Error) => {

package/Server/Services/TeamMemberService.ts

@@ -90,6 +90,7 @@ export class TeamMemberService extends DatabaseService<TeamMember> {
         isNewUser = true;
         user = await UserService.createByEmail({
           email,
+          name: undefined, // name is not required for now.
           props: {
             isRoot: true,
           },

package/Server/Services/UserService.ts

@@ -32,6 +32,7 @@ import SlackUtil from "../Utils/Slack/Slack";
 import UserTwoFactorAuth from "Common/Models/DatabaseModels/UserTwoFactorAuth";
 import UserTwoFactorAuthService from "./UserTwoFactorAuthService";
 import BadDataException from "../../Types/Exception/BadDataException";
+import Name from "../../Types/Name";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
@@ -43,7 +44,7 @@ export class Service extends DatabaseService<Model> {
     createdItem: Model,
   ): Promise<Model> {
     if (NotificationSlackWebhookOnCreateUser) {
-      SlackUtil.sendMessageToChannel({
+      SlackUtil.sendMessageToChannelViaIncomingWebhook({
         url: URL.fromString(NotificationSlackWebhookOnCreateUser),
         text: `*New OneUptime User:* 
   *Email:* ${createdItem.email?.toString() || "N/A"}
@@ -292,6 +293,7 @@ export class Service extends DatabaseService<Model> {
 
   public async createByEmail(data: {
     email: Email;
+    name: Name | undefined;
     isEmailVerified?: boolean;
     generateRandomPassword?: boolean;
     props: DatabaseCommonInteractionProps;
@@ -300,6 +302,9 @@ export class Service extends DatabaseService<Model> {
 
     const user: Model = new Model();
     user.email = email;
+    if (data.name) {
+      user.name = data.name;
+    }
     user.isEmailVerified = data.isEmailVerified || false;
 
     if (data.generateRandomPassword) {

package/Server/Services/WorkspaceNotificationRuleService.ts

@@ -1,7 +1,8 @@
 import NotificationRuleEventType from "../../Types/Workspace/NotificationRules/EventType";
-import { WorkspaceNotificationPayload } from "../../Types/Workspace/WorkspaceNotificationPayload";
+import WorkspaceNotificationPayload from "../../Types/Workspace/WorkspaceNotificationPayload";
 import WorkspaceType from "../../Types/Workspace/WorkspaceType";
 import logger from "../Utils/Logger";
+import SlackUtil from "../Utils/Slack/Slack";
 import DatabaseService from "./DatabaseService";
 import Model from "Common/Models/DatabaseModels/WorkspaceNotificationRule";
 
@@ -10,13 +11,21 @@ export class Service extends DatabaseService<Model> {
     super(Model);
   }
 
-  public async notifyWorkspace(data: {
+  public async sendMessage(data: {
     workspaceType: WorkspaceType;
     notificationRuleEventType: NotificationRuleEventType;
     workspaceNotificationPayload: WorkspaceNotificationPayload;
+    authToken: string; // which auth token should we use to send.
   }): Promise<void> {
     logger.debug("Notify Workspace");
     logger.debug(data);
+
+    if (data.workspaceType === WorkspaceType.Slack) {
+      await SlackUtil.sendMessage({
+        workspaceNotificationPayload: data.workspaceNotificationPayload,
+        authToken: data.authToken,
+      });
+    }
   }
 }
 export default new Service();

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

@@ -69,7 +69,7 @@ export default class SendMessageToChannel extends ComponentCode {
 
     try {
       // https://api.slack.com/messaging/webhooks#advanced_message_formatting
-      apiResult = await SlackUtil.sendMessageToChannel({
+      apiResult = await SlackUtil.sendMessageToChannelViaIncomingWebhook({
         url: args["webhook-url"] as URL,
         text: args["text"] as string,
       });

package/Server/Utils/Slack/Slack.ts

@@ -3,49 +3,209 @@ import HTTPResponse from "Common/Types/API/HTTPResponse";
 import URL from "Common/Types/API/URL";
 import { JSONObject } from "Common/Types/JSON";
 import API from "Common/Utils/API";
+import WorkspaceNotificationPayload, {
+  WorkspaceNotificationPayloadButton,
+  WorkspacePayloadButtons,
+  WorkspacePayloadHeader,
+  WorkspacePayloadMarkdown,
+} from "../../../Types/Workspace/WorkspaceNotificationPayload";
+import logger from "../Logger";
+import Dictionary from "../../../Types/Dictionary";
+import BadRequestException from "../../../Types/Exception/BadRequestException";
+
+export interface JobResponse {
+  isSuccessful: boolean;
+  errorMessage?: string | undefined;
+}
+
+export interface SlackChannel {
+  id: string;
+  name: string;
+}
 
 export default class SlackUtil {
-  public async getTextboxField(data: {
-    title: string;
-    placeholder: string;
-    actionId: string;
-    initialValue?: string;
-  }): Promise<JSONObject> {
-    return {
-      type: "input",
-      element: {
-        type: "plain_text_input",
-        action_id: data.actionId,
-        placeholder: {
-          type: "plain_text",
-          text: data.placeholder,
+  public static async sendMessage(data: {
+    workspaceNotificationPayload: WorkspaceNotificationPayload;
+    authToken: string; // which auth token should we use to send.
+  }): Promise<void> {
+    logger.debug("Notify Slack");
+    logger.debug(data);
+
+    const blocks: Array<JSONObject> =
+      this.getSlackBlocksFromWorkspaceNotificationPayload(
+        data.workspaceNotificationPayload,
+      );
+
+    const existingSlackChannels: Dictionary<SlackChannel> =
+      await this.getSlackChannels({
+        authToken: data.authToken,
+      });
+
+    for (const channelName of data.workspaceNotificationPayload.channelNames) {
+      // get channel ids from existingSlackChannels. IF channel doesn't exist, create it if createChannelsIfItDoesNotExist is true.
+      let channel: SlackChannel | null = null;
+
+      if (existingSlackChannels[channelName]) {
+        channel = existingSlackChannels[channelName]!;
+      } else if (
+        data.workspaceNotificationPayload.createChannelsIfItDoesNotExist
+      ) {
+        channel = await this.createChannel({
+          authToken: data.authToken,
+          channelName: channelName,
+        });
+      }
+
+      if (channel) {
+        await this.sendPayloadBlocksToChannel({
+          authToken: data.authToken,
+          channelId: channel.id,
+          blocks: blocks,
+        });
+      } else {
+        logger.debug(
+          `Channel ${channelName} does not exist and createChannelsIfItDoesNotExist is false.`,
+        );
+      }
+    }
+  }
+
+  public static async sendPayloadBlocksToChannel(data: {
+    authToken: string;
+    channelId: string;
+    blocks: Array<JSONObject>;
+  }): Promise<void> {
+    const response: HTTPErrorResponse | HTTPResponse<JSONObject> =
+      await API.post(
+        URL.fromString("https://slack.com/api/chat.postMessage"),
+        {
+          channel: data.channelId,
+          blocks: data.blocks,
         },
-        initial_value: data.initialValue,
-      },
-      label: {
+        {
+          Authorization: `Bearer ${data.authToken}`,
+        },
+      );
+
+    if (response instanceof HTTPErrorResponse) {
+      throw response;
+    }
+
+    if ((response.jsonData as JSONObject)?.["ok"] !== true) {
+      throw new BadRequestException("Invalid response");
+    }
+  }
+
+  public static async createChannel(data: {
+    authToken: string;
+    channelName: string;
+  }): Promise<SlackChannel> {
+    const response: HTTPResponse<JSONObject> | HTTPErrorResponse =
+      await API.post(
+        URL.fromString("https://slack.com/api/conversations.create"),
+        {
+          name: data.channelName,
+        },
+        {
+          Authorization: `Bearer ${data.authToken}`,
+        },
+      );
+
+    if (response instanceof HTTPErrorResponse) {
+      throw response;
+    }
+
+    if (
+      !((response.jsonData as JSONObject)?.["channel"] as JSONObject)?.["id"] ||
+      !((response.jsonData as JSONObject)?.["channel"] as JSONObject)?.["name"]
+    ) {
+      throw new Error("Invalid response");
+    }
+
+    return {
+      id: ((response.jsonData as JSONObject)["channel"] as JSONObject)[
+        "id"
+      ] as string,
+      name: ((response.jsonData as JSONObject)["channel"] as JSONObject)[
+        "name"
+      ] as string,
+    };
+  }
+
+  public static getHeaderBlock(data: {
+    payloadHeaderBlock: WorkspacePayloadHeader;
+  }): JSONObject {
+    return {
+      type: "header",
+      text: {
         type: "plain_text",
-        text: data.title,
+        text: data.payloadHeaderBlock.text,
       },
     };
   }
 
-  public getButtonField(data: {
-    text: string;
-    actionId: string;
-    value: string;
+  public static getMarkdownBlock(data: {
+    payloadMarkdownBlock: WorkspacePayloadMarkdown;
+  }): JSONObject {
+    return {
+      type: "section",
+      text: {
+        type: "mrkdwn",
+        text: data.payloadMarkdownBlock.text,
+      },
+    };
+  }
+
+  public static async getSlackChannels(data: {
+    authToken: string;
+  }): Promise<Dictionary<SlackChannel>> {
+    const response: HTTPErrorResponse | HTTPResponse<JSONObject> =
+      await API.get<JSONObject>(
+        URL.fromString("https://slack.com/api/conversations.list"),
+        {
+          headers: {
+            Authorization: `Bearer ${data.authToken}`,
+          },
+        },
+      );
+
+    if (response instanceof HTTPErrorResponse) {
+      throw response;
+    }
+
+    const channels: Dictionary<SlackChannel> = {};
+
+    for (const channel of (response.jsonData as JSONObject)[
+      "channels"
+    ] as Array<JSONObject>) {
+      if (!channel["id"] || !channel["name"]) {
+        continue;
+      }
+
+      channels[channel["name"].toString()] = {
+        id: channel["id"] as string,
+        name: channel["name"] as string,
+      };
+    }
+
+    return channels;
+  }
+
+  public static getButtonBlock(data: {
+    payloadButtonBlock: WorkspaceNotificationPayloadButton;
   }): JSONObject {
     return {
       type: "button",
       text: {
         type: "plain_text",
-        text: data.text,
+        text: data.payloadButtonBlock.title,
       },
-      action_id: data.actionId,
-      value: data.value,
+      value: data.payloadButtonBlock.title,
+      action_id: data.payloadButtonBlock.title,
     };
   }
 
-  public static async sendMessageToChannel(data: {
+  public static async sendMessageToChannelViaIncomingWebhook(data: {
     url: URL;
     text: string;
   }): Promise<HTTPResponse<JSONObject> | HTTPErrorResponse> {
@@ -66,4 +226,46 @@ export default class SlackUtil {
 
     return apiResult;
   }
+
+  private static getSlackBlocksFromWorkspaceNotificationPayload(
+    data: WorkspaceNotificationPayload,
+  ): Array<JSONObject> {
+    const blocks: Array<JSONObject> = [];
+    const buttons: Array<JSONObject> = [];
+    for (const block of data.blocks) {
+      switch (block._type) {
+        case "WorkspacePayloadHeader":
+          blocks.push(
+            this.getHeaderBlock({
+              payloadHeaderBlock: block as WorkspacePayloadHeader,
+            }),
+          );
+          break;
+        case "WorkspacePayloadMarkdown":
+          blocks.push(
+            this.getMarkdownBlock({
+              payloadMarkdownBlock: block as WorkspacePayloadMarkdown,
+            }),
+          );
+          break;
+        case "WorkspacePayloadButtons":
+          for (const button of (block as WorkspacePayloadButtons).buttons) {
+            buttons.push(
+              this.getButtonBlock({
+                payloadButtonBlock: button,
+              }),
+            );
+          }
+          blocks.push({
+            type: "actions",
+            elements: buttons,
+          });
+          break;
+        default:
+          logger.error("Unknown block type: " + block._type);
+          break;
+      }
+    }
+    return blocks;
+  }
 }

package/Types/Workspace/WorkspaceNotificationPayload.ts

@@ -1,3 +1,29 @@
-export interface WorkspaceNotificationPayload {
+export interface WorkspacePayloadBlocks {
+  _type: string;
+}
+
+export interface WorkspaceNotificationPayloadButton {
+  title: string; // Button title.
+}
+
+export interface WorkspacePayloadHeader extends WorkspacePayloadBlocks {
+  _type: "WorkspacePayloadHeader";
+  text: string;
+}
+
+export interface WorkspacePayloadMarkdown extends WorkspacePayloadBlocks {
+  _type: "WorkspacePayloadMarkdown";
+  text: string;
+}
+
+export interface WorkspacePayloadButtons extends WorkspacePayloadBlocks {
+  _type: "WorkspacePayloadButtons";
+  buttons: Array<WorkspaceNotificationPayloadButton>;
+}
+
+export default interface WorkspaceNotificationPayload {
   _type: "WorkspaceNotificationPayload";
+  channelNames: Array<string>; // which channels to post to.
+  blocks: Array<WorkspacePayloadBlocks>; // Buttons to add to the message.
+  createChannelsIfItDoesNotExist: boolean; // Should we create the channels if they don't exist.
 }

package/build/dist/Models/DatabaseModels/Alert.js

@@ -68,6 +68,7 @@ let Alert = class Alert extends BaseModel {
         this.remediationNotes = undefined;
         this.telemetryQuery = undefined;
         this.alertNumber = undefined;
+        this.postUpdatesToSlackChannelId = undefined;
     }
 };
 __decorate([
@@ -1000,6 +1001,26 @@ __decorate([
     }),
     __metadata("design:type", Number)
 ], Alert.prototype, "alertNumber", void 0);
+__decorate([
+    ColumnAccessControl({
+        create: [],
+        read: [],
+        update: [],
+    }),
+    TableColumn({
+        isDefaultValueColumn: false,
+        required: false,
+        type: TableColumnType.ShortText,
+        title: "Post Updates To Slack Channel ID",
+        description: "Post Updates To Slack Channel ID",
+    }),
+    Column({
+        type: ColumnType.ShortText,
+        length: ColumnLength.ShortText,
+        nullable: true,
+    }),
+    __metadata("design:type", Number)
+], Alert.prototype, "postUpdatesToSlackChannelId", void 0);
 Alert = __decorate([
     EnableDocumentation(),
     AccessControlColumn("labels"),