@oneuptime/common 7.0.3652 → 7.0.3668

package/Server/Utils/Slack/Slack.ts

@@ -3,49 +3,342 @@ 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 WorkspaceMessagePayload, {
+  WorkspaceMessagePayloadButton,
+  WorkspacePayloadButtons,
+  WorkspacePayloadHeader,
+  WorkspacePayloadMarkdown,
+} from "../../../Types/Workspace/WorkspaceMessagePayload";
+import logger from "../Logger";
+import Dictionary from "../../../Types/Dictionary";
+import BadRequestException from "../../../Types/Exception/BadRequestException";
+import WorkspaceChannelInvitationPayload from "../../../Types/Workspace/WorkspaceChannelInvitationPayload";
+
+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 inviteUsersToChannels(data: {
+    authToken: string;
+    workspaceChannelInvitationPayload: WorkspaceChannelInvitationPayload;
+  }): Promise<void> {
+    const channelIds: Array<string> = [];
+
+    for (const channelName of data.workspaceChannelInvitationPayload
+      .workspaceChannelNames) {
+      const channel: SlackChannel = await this.createChannel({
+        authToken: data.authToken,
+        channelName: channelName,
+      });
+
+      channelIds.push(channel.id);
+    }
+
+    for (const channelId of channelIds) {
+      await this.inviteUsersToChannel({
+        authToken: data.authToken,
+        channelId: channelId,
+        userIds: data.workspaceChannelInvitationPayload.workspaceUserIds,
+      });
+    }
+  }
+
+  private static async inviteUsersToChannel(data: {
+    authToken: string;
+    channelId: string;
+    userIds: Array<string>;
+  }): Promise<void> {
+    for (const userId of data.userIds) {
+      await this.inviteUserToChannel({
+        authToken: data.authToken,
+        channelId: data.channelId,
+        userId: userId,
+      });
+    }
+  }
+
+  private static async inviteUserToChannel(data: {
+    authToken: string;
+    channelId: string;
+    userId: string;
+  }): Promise<void> {
+    const response: HTTPErrorResponse | HTTPResponse<JSONObject> =
+      await API.post(
+        URL.fromString("https://slack.com/api/conversations.invite"),
+        {
+          channel: data.channelId,
+          users: data.userId,
         },
-        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 createChannelIfDoesNotExist(data: {
+    authToken: string;
+    channelNamesToCreate: Array<string>;
+  }): Promise<Array<string>> {
+    // check existing channels and only create if they dont exist.
+    const channelIds: Array<string> = [];
+    const existingSlackChannels: Dictionary<SlackChannel> =
+      await this.getSlackChannels({
+        authToken: data.authToken,
+      });
+
+    for (const channelName of data.channelNamesToCreate) {
+      if (existingSlackChannels[channelName]) {
+        logger.debug(`Channel ${channelName} already exists.`);
+
+        channelIds.push(existingSlackChannels[channelName]!.id);
+
+        continue;
+      }
+
+      const channel: SlackChannel = await this.createChannel({
+        authToken: data.authToken,
+        channelName: channelName,
+      });
+
+      if (channel) {
+        channelIds.push(channel.id);
+      }
+    }
+
+    return channelIds;
+  }
+
+  public static async getChannelNameFromChannelId(data: {
+    authToken: string;
+    channelId: string;
+  }): Promise<string> {
+    const response: HTTPErrorResponse | HTTPResponse<JSONObject> =
+      await API.get<JSONObject>(
+        URL.fromString("https://slack.com/api/conversations.info"),
+        {
+          headers: {
+            Authorization: `Bearer ${data.authToken}`,
+          },
+          params: {
+            channel: data.channelId,
+          },
+        },
+      );
+
+    if (response instanceof HTTPErrorResponse) {
+      throw response;
+    }
+
+    if (
+      !((response.jsonData as JSONObject)?.["channel"] as JSONObject)?.["name"]
+    ) {
+      throw new Error("Invalid response");
+    }
+
+    return ((response.jsonData as JSONObject)["channel"] as JSONObject)[
+      "name"
+    ] as string;
+  }
+
+  public static async sendMessage(data: {
+    workspaceMessagePayload: WorkspaceMessagePayload;
+    authToken: string; // which auth token should we use to send.
+  }): Promise<void> {
+    logger.debug("Notify Slack");
+    logger.debug(data);
+
+    const blocks: Array<JSONObject> =
+      this.getSlackBlocksFromWorkspaceMessagePayload(
+        data.workspaceMessagePayload,
+      );
+
+    const existingSlackChannels: Dictionary<SlackChannel> =
+      await this.getSlackChannels({
+        authToken: data.authToken,
+      });
+
+    const channelIdsToPostTo: Array<string> = [];
+
+    for (const channelName of data.workspaceMessagePayload.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]!;
+      }
+
+      if (channel) {
+        channelIdsToPostTo.push(channel.id);
+      } else {
+        logger.debug(`Channel ${channelName} does not exist.`);
+      }
+    }
+
+    for (const channelId of channelIdsToPostTo) {
+      try {
+        // try catch here to prevent failure of one channel to prevent posting to other channels.
+        await this.sendPayloadBlocksToChannel({
+          authToken: data.authToken,
+          channelId: channelId,
+          blocks: blocks,
+        });
+      } catch (e) {
+        logger.error(e);
+      }
+    }
+  }
+
+  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,
+        },
+        {
+          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: WorkspaceMessagePayloadButton;
   }): 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 +359,46 @@ export default class SlackUtil {
 
     return apiResult;
   }
+
+  private static getSlackBlocksFromWorkspaceMessagePayload(
+    data: WorkspaceMessagePayload,
+  ): Array<JSONObject> {
+    const blocks: Array<JSONObject> = [];
+    const buttons: Array<JSONObject> = [];
+    for (const block of data.messageBlocks) {
+      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/NotificationRules/BaseNotificationRule.ts

@@ -1,3 +1,12 @@
+import FilterCondition from "../../Filter/FilterCondition";
+import NotificationRuleCondition from "./NotificationRuleCondition";
+
 export default interface BaseNotificationRule {
   _type: string;
+  // filters for notification rule
+  filterCondition: FilterCondition; // and OR or. Default is AND
+  filters: Array<NotificationRuleCondition>; // if this array is empty then it will be considered as all filters are matched.
+
+  shouldPostToExistingChannel: boolean;
+  existingChannelNames: string; // seperate by comma
 }

package/Types/Workspace/NotificationRules/NotificationRuleCondition.ts

@@ -7,24 +7,23 @@ import Monitor from "../../../Models/DatabaseModels/Monitor";
 import MonitorStatus from "../../../Models/DatabaseModels/MonitorStatus";
 import ScheduledMaintenanceState from "../../../Models/DatabaseModels/ScheduledMaintenanceState";
 import { DropdownOption } from "../../../UI/Components/Dropdown/Dropdown";
-import ObjectID from "../../ObjectID";
 import WorkspaceType from "../WorkspaceType";
 import NotificationRuleEventType from "./EventType";
-import SlackNotificationRule from "./SlackNotificationRule";
+import IncidentNotificationRule from "./NotificationRuleTypes/IncidentNotificationRule";
 
 export enum NotificationRuleConditionCheckOn {
   MonitorName = "Monitor Name",
-  IncidentName = "Incident Name",
+  IncidentTitle = "Incident Title",
   IncidentDescription = "Incident Description",
   IncidentSeverity = "Incident Severity",
   IncidentState = "Incident State",
   MonitorType = "Monitor Type",
   MonitorStatus = "Monitor Status",
-  AlertName = "Alert Name",
+  AlertTitle = "Alert Title",
   AlertDescription = "Alert Description",
   AlertSeverity = "Alert Severity",
   AlertState = "Alert State",
-  ScheduledMaintenanceName = "Scheduled Maintenance Name",
+  ScheduledMaintenanceTitle = "Scheduled Maintenance Title",
   ScheduledMaintenanceDescription = "Scheduled Maintenance Description",
   ScheduledMaintenanceState = "Scheduled Maintenance State",
   IncidentLabels = "Incident Labels",
@@ -41,7 +40,7 @@ export enum ConditionType {
   LessThan = "Less Than",
   GreaterThanOrEqualTo = "Greater Than Or Equal To",
   LessThanOrEqualTo = "Less Than Or Equal To",
-  Contains = "Contains",
+  ContainsAny = "Contains Any",
   NotContains = "Not Contains",
   StartsWith = "Starts With",
   EndsWith = "Ends With",
@@ -49,26 +48,18 @@ export enum ConditionType {
   IsNotEmpty = "Is Not Empty",
   True = "True",
   False = "False",
-
-  // could be used for labels.
   ContainsAll = "Contains All",
 }
 
 export default interface NotificationRuleCondition {
   checkOn: NotificationRuleConditionCheckOn;
   conditionType: ConditionType | undefined;
-  value:
-    | string
-    | number
-    | boolean
-    | Array<string>
-    | Array<ObjectID>
-    | undefined;
+  value: string | Array<string> | undefined;
 }
 
 export class NotificationRuleConditionUtil {
   public static getValidationError(data: {
-    notificationRule: SlackNotificationRule;
+    notificationRule: IncidentNotificationRule;
     eventType: NotificationRuleEventType;
     workspaceType: WorkspaceType;
   }): string | null {
@@ -97,14 +88,14 @@ export class NotificationRuleConditionUtil {
 
       if (workspaceType === WorkspaceType.Slack) {
         if (
-          !notificationRule.shouldCreateSlackChannel &&
-          !notificationRule.shouldPostToExistingSlackChannel
+          !notificationRule.shouldCreateNewChannel &&
+          !notificationRule.shouldPostToExistingChannel
         ) {
           return "Please select either create slack channel or post to existing slack channel";
         }
 
-        if (notificationRule.shouldPostToExistingSlackChannel) {
-          if (!notificationRule.existingSlackChannelName?.trim()) {
+        if (notificationRule.shouldPostToExistingChannel) {
+          if (!notificationRule.existingChannelNames?.trim()) {
             return "Existing Slack channel name is required";
           }
         }
@@ -262,7 +253,7 @@ export class NotificationRuleConditionUtil {
     switch (eventType) {
       case NotificationRuleEventType.Incident:
         return [
-          NotificationRuleConditionCheckOn.IncidentName,
+          NotificationRuleConditionCheckOn.IncidentTitle,
           NotificationRuleConditionCheckOn.IncidentDescription,
           NotificationRuleConditionCheckOn.IncidentSeverity,
           NotificationRuleConditionCheckOn.IncidentState,
@@ -272,7 +263,7 @@ export class NotificationRuleConditionUtil {
         ];
       case NotificationRuleEventType.Alert:
         return [
-          NotificationRuleConditionCheckOn.AlertName,
+          NotificationRuleConditionCheckOn.AlertTitle,
           NotificationRuleConditionCheckOn.AlertDescription,
           NotificationRuleConditionCheckOn.AlertSeverity,
           NotificationRuleConditionCheckOn.AlertState,
@@ -292,7 +283,7 @@ export class NotificationRuleConditionUtil {
         ];
       case NotificationRuleEventType.ScheduledMaintenance:
         return [
-          NotificationRuleConditionCheckOn.ScheduledMaintenanceName,
+          NotificationRuleConditionCheckOn.ScheduledMaintenanceTitle,
           NotificationRuleConditionCheckOn.ScheduledMaintenanceDescription,
           NotificationRuleConditionCheckOn.ScheduledMaintenanceState,
           NotificationRuleConditionCheckOn.ScheduledMaintenanceLabels,
@@ -309,42 +300,42 @@ export class NotificationRuleConditionUtil {
   ): Array<ConditionType> {
     switch (checkOn) {
       case NotificationRuleConditionCheckOn.MonitorName:
-      case NotificationRuleConditionCheckOn.IncidentName:
+      case NotificationRuleConditionCheckOn.IncidentTitle:
       case NotificationRuleConditionCheckOn.IncidentDescription:
-      case NotificationRuleConditionCheckOn.AlertName:
+      case NotificationRuleConditionCheckOn.AlertTitle:
       case NotificationRuleConditionCheckOn.AlertDescription:
-      case NotificationRuleConditionCheckOn.ScheduledMaintenanceName:
+      case NotificationRuleConditionCheckOn.ScheduledMaintenanceTitle:
       case NotificationRuleConditionCheckOn.ScheduledMaintenanceDescription:
         return [
           ConditionType.EqualTo,
           ConditionType.NotEqualTo,
-          ConditionType.Contains,
+          ConditionType.ContainsAny,
           ConditionType.NotContains,
           ConditionType.StartsWith,
           ConditionType.EndsWith,
         ];
       case NotificationRuleConditionCheckOn.IncidentSeverity:
       case NotificationRuleConditionCheckOn.AlertSeverity:
-        return [ConditionType.Contains, ConditionType.NotContains];
+        return [ConditionType.ContainsAny, ConditionType.NotContains];
       case NotificationRuleConditionCheckOn.IncidentState:
       case NotificationRuleConditionCheckOn.AlertState:
       case NotificationRuleConditionCheckOn.MonitorStatus:
       case NotificationRuleConditionCheckOn.ScheduledMaintenanceState:
-        return [ConditionType.Contains, ConditionType.NotContains];
+        return [ConditionType.ContainsAny, ConditionType.NotContains];
       case NotificationRuleConditionCheckOn.MonitorType:
-        return [ConditionType.Contains, ConditionType.NotContains];
+        return [ConditionType.ContainsAny, ConditionType.NotContains];
       case NotificationRuleConditionCheckOn.AlertLabels:
       case NotificationRuleConditionCheckOn.IncidentLabels:
       case NotificationRuleConditionCheckOn.MonitorLabels:
       case NotificationRuleConditionCheckOn.ScheduledMaintenanceLabels:
         return [
-          ConditionType.Contains,
+          ConditionType.ContainsAny,
           ConditionType.NotContains,
           ConditionType.ContainsAll,
         ];
       case NotificationRuleConditionCheckOn.Monitors:
         return [
-          ConditionType.Contains,
+          ConditionType.ContainsAny,
           ConditionType.NotContains,
           ConditionType.ContainsAll,
         ];

package/Types/Workspace/NotificationRules/NotificationRuleTypes/AlertNotificationRule.ts

@@ -0,0 +1,15 @@
+import ObjectID from "../../../ObjectID";
+import BaseNotificationRule from "../BaseNotificationRule";
+
+export default interface AlertNotificationRule extends BaseNotificationRule {
+  _type: "AlertNotificationRule";
+
+  // if filters match then do:
+  shouldCreateNewChannel: boolean;
+  inviteTeamsToNewChannel: Array<ObjectID>;
+  inviteUsersToNewChannel: Array<ObjectID>;
+
+  shouldInviteOwnersToNewChannel: boolean;
+
+  shouldAutomaticallyInviteOnCallUsersToNewChannel: boolean;
+}

package/Types/Workspace/NotificationRules/NotificationRuleTypes/IncidentNotificationRule.ts

@@ -0,0 +1,15 @@
+import ObjectID from "../../../ObjectID";
+import BaseNotificationRule from "../BaseNotificationRule";
+
+export default interface IncidentNotificationRule extends BaseNotificationRule {
+  _type: "IncidentNotificationRule";
+
+  // if filters match then do:
+  shouldCreateNewChannel: boolean;
+  inviteTeamsToNewChannel: Array<ObjectID>;
+  inviteUsersToNewChannel: Array<ObjectID>;
+
+  shouldInviteOwnersToNewChannel: boolean;
+
+  shouldAutomaticallyInviteOnCallUsersToNewChannel: boolean;
+}

package/Types/Workspace/NotificationRules/NotificationRuleTypes/MonitorStatusNotificationRule.ts

@@ -0,0 +1,7 @@
+import BaseNotificationRule from "../BaseNotificationRule";
+
+// This rule is just used to post to existing channels.
+export default interface MonitorStatusNotificationRule
+  extends BaseNotificationRule {
+  _type: "MonitorStatusNotificationRule";
+}

package/Types/Workspace/NotificationRules/NotificationRuleTypes/ScheduledMaintenanceNotificationRule.ts

@@ -0,0 +1,14 @@
+import ObjectID from "../../../ObjectID";
+import BaseNotificationRule from "../BaseNotificationRule";
+
+export default interface ScheduledMaintenanceNotificationRule
+  extends BaseNotificationRule {
+  _type: "ScheduledMaintenanceNotificationRule";
+
+  // if filters match then do:
+  shouldCreateNewChannel: boolean;
+  inviteTeamsToNewChannel: Array<ObjectID>;
+  inviteUsersToNewChannel: Array<ObjectID>;
+
+  shouldInviteOwnersToNewChannel: boolean;
+}