@oneuptime/common 7.0.3669 → 7.0.3679

package/Server/Utils/{Slack → Workspace/Slack}/Slack.ts

@@ -5,76 +5,34 @@ 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 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: {
+} from "../../../../Types/Workspace/WorkspaceMessagePayload";
+import logger from "../../Logger";
+import Dictionary from "../../../../Types/Dictionary";
+import BadRequestException from "../../../../Types/Exception/BadRequestException";
+import WorkspaceBase, { WorkspaceChannel } from "../WorkspaceBase";
+import WorkspaceType from "../../../../Types/Workspace/WorkspaceType";
+
+export default class SlackUtil extends WorkspaceBase {
+  public static override async inviteUserToChannel(data: {
     authToken: string;
-    channelId: string;
-    userIds: Array<string>;
+    channelName: string;
+    workspaceUserId: string;
   }): Promise<void> {
-    for (const userId of data.userIds) {
-      await this.inviteUserToChannel({
+    const channelId: string = (
+      await this.getWorkspaceChannelFromChannelId({
         authToken: data.authToken,
-        channelId: data.channelId,
-        userId: userId,
-      });
-    }
-  }
+        channelId: data.channelName,
+      })
+    ).id;
 
-  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,
+          channel: channelId,
+          users: data.workspaceUserId,
         },
         {
           Authorization: `Bearer ${data.authToken}`,
@@ -90,43 +48,43 @@ export default class SlackUtil {
     }
   }
 
-  public static async createChannelIfDoesNotExist(data: {
+  public static override async createChannelsIfDoesNotExist(data: {
     authToken: string;
-    channelNamesToCreate: Array<string>;
-  }): Promise<Array<string>> {
+    channelNames: Array<string>;
+  }): Promise<Array<WorkspaceChannel>> {
     // check existing channels and only create if they dont exist.
-    const channelIds: Array<string> = [];
-    const existingSlackChannels: Dictionary<SlackChannel> =
-      await this.getSlackChannels({
+    const workspaceChannels: Array<WorkspaceChannel> = [];
+    const existingWorkspaceChannels: Dictionary<WorkspaceChannel> =
+      await this.getAllWorkspaceChannels({
         authToken: data.authToken,
       });
 
-    for (const channelName of data.channelNamesToCreate) {
-      if (existingSlackChannels[channelName]) {
+    for (const channelName of data.channelNames) {
+      if (existingWorkspaceChannels[channelName]) {
         logger.debug(`Channel ${channelName} already exists.`);
 
-        channelIds.push(existingSlackChannels[channelName]!.id);
+        workspaceChannels.push(existingWorkspaceChannels[channelName]!);
 
         continue;
       }
 
-      const channel: SlackChannel = await this.createChannel({
+      const channel: WorkspaceChannel = await this.createChannel({
         authToken: data.authToken,
         channelName: channelName,
       });
 
       if (channel) {
-        channelIds.push(channel.id);
+        workspaceChannels.push(channel);
       }
     }
 
-    return channelIds;
+    return workspaceChannels;
   }
 
-  public static async getChannelNameFromChannelId(data: {
+  public static override async getWorkspaceChannelFromChannelId(data: {
     authToken: string;
     channelId: string;
-  }): Promise<string> {
+  }): Promise<WorkspaceChannel> {
     const response: HTTPErrorResponse | HTTPResponse<JSONObject> =
       await API.get<JSONObject>(
         URL.fromString("https://slack.com/api/conversations.info"),
@@ -150,36 +108,75 @@ export default class SlackUtil {
       throw new Error("Invalid response");
     }
 
-    return ((response.jsonData as JSONObject)["channel"] as JSONObject)[
-      "name"
-    ] as string;
+    return {
+      name: ((response.jsonData as JSONObject)["channel"] as JSONObject)[
+        "name"
+      ] as string,
+      id: data.channelId,
+      workspaceType: WorkspaceType.Slack,
+    };
   }
 
-  public static async sendMessage(data: {
+  public static override async getAllWorkspaceChannels(data: {
+    authToken: string;
+  }): Promise<Dictionary<WorkspaceChannel>> {
+    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<WorkspaceChannel> = {};
+
+    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,
+        workspaceType: WorkspaceType.Slack,
+      };
+    }
+
+    return channels;
+  }
+
+  public static override 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 blocks: Array<JSONObject> = this.getBlocksFromWorkspaceMessagePayload(
+      data.workspaceMessagePayload,
+    );
 
-    const existingSlackChannels: Dictionary<SlackChannel> =
-      await this.getSlackChannels({
+    const existingWorkspaceChannels: Dictionary<WorkspaceChannel> =
+      await this.getAllWorkspaceChannels({
         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;
+      // get channel ids from existingWorkspaceChannels. IF channel doesn't exist, create it if createChannelsIfItDoesNotExist is true.
+      let channel: WorkspaceChannel | null = null;
 
-      if (existingSlackChannels[channelName]) {
-        channel = existingSlackChannels[channelName]!;
+      if (existingWorkspaceChannels[channelName]) {
+        channel = existingWorkspaceChannels[channelName]!;
       }
 
       if (channel) {
@@ -203,7 +200,7 @@ export default class SlackUtil {
     }
   }
 
-  public static async sendPayloadBlocksToChannel(data: {
+  public static override async sendPayloadBlocksToChannel(data: {
     authToken: string;
     channelId: string;
     blocks: Array<JSONObject>;
@@ -229,10 +226,10 @@ export default class SlackUtil {
     }
   }
 
-  public static async createChannel(data: {
+  public static override async createChannel(data: {
     authToken: string;
     channelName: string;
-  }): Promise<SlackChannel> {
+  }): Promise<WorkspaceChannel> {
     const response: HTTPResponse<JSONObject> | HTTPErrorResponse =
       await API.post(
         URL.fromString("https://slack.com/api/conversations.create"),
@@ -262,10 +259,11 @@ export default class SlackUtil {
       name: ((response.jsonData as JSONObject)["channel"] as JSONObject)[
         "name"
       ] as string,
+      workspaceType: WorkspaceType.Slack,
     };
   }
 
-  public static getHeaderBlock(data: {
+  public static override getHeaderBlock(data: {
     payloadHeaderBlock: WorkspacePayloadHeader;
   }): JSONObject {
     return {
@@ -277,7 +275,7 @@ export default class SlackUtil {
     };
   }
 
-  public static getMarkdownBlock(data: {
+  public static override getMarkdownBlock(data: {
     payloadMarkdownBlock: WorkspacePayloadMarkdown;
   }): JSONObject {
     return {
@@ -289,42 +287,7 @@ export default class SlackUtil {
     };
   }
 
-  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: {
+  public static override getButtonBlock(data: {
     payloadButtonBlock: WorkspaceMessagePayloadButton;
   }): JSONObject {
     return {
@@ -338,7 +301,7 @@ export default class SlackUtil {
     };
   }
 
-  public static async sendMessageToChannelViaIncomingWebhook(data: {
+  public static override async sendMessageToChannelViaIncomingWebhook(data: {
     url: URL;
     text: string;
   }): Promise<HTTPResponse<JSONObject> | HTTPErrorResponse> {
@@ -359,46 +322,4 @@ 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/Server/Utils/Workspace/Workspace.ts

@@ -0,0 +1,23 @@
+import WorkspaceType from "../../../Types/Workspace/WorkspaceType";
+import WorkspaceBase from "./WorkspaceBase";
+import SlackWorkspace from "./Slack/Slack";
+import MicrosoftTeamsWorkspace from "./MicrosoftTeams/MicrosoftTeams";
+import BadDataException from "../../../Types/Exception/BadDataException";
+
+export default class WorkspaceUtil {
+  public static getWorkspaceTypeUtil(
+    workspaceType: WorkspaceType,
+  ): typeof WorkspaceBase {
+    if (workspaceType === WorkspaceType.Slack) {
+      return SlackWorkspace;
+    }
+
+    if (workspaceType === WorkspaceType.MicrosoftTeams) {
+      return MicrosoftTeamsWorkspace;
+    }
+
+    throw new BadDataException(
+      `Workspace type ${workspaceType} is not supported`,
+    );
+  }
+}

package/Server/Utils/Workspace/WorkspaceBase.ts

@@ -0,0 +1,169 @@
+import HTTPErrorResponse from "../../../Types/API/HTTPErrorResponse";
+import HTTPResponse from "../../../Types/API/HTTPResponse";
+import Dictionary from "../../../Types/Dictionary";
+import NotImplementedException from "../../../Types/Exception/NotImplementedException";
+import { JSONObject } from "../../../Types/JSON";
+import WorkspaceChannelInvitationPayload from "../../../Types/Workspace/WorkspaceChannelInvitationPayload";
+import WorkspaceMessagePayload, {
+  WorkspaceMessagePayloadButton,
+  WorkspacePayloadButtons,
+  WorkspacePayloadHeader,
+  WorkspacePayloadMarkdown,
+} from "../../../Types/Workspace/WorkspaceMessagePayload";
+import WorkspaceType from "../../../Types/Workspace/WorkspaceType";
+import logger from "../Logger";
+import URL from "Common/Types/API/URL";
+
+export interface WorkspaceChannel {
+  id: string;
+  name: string;
+  workspaceType: WorkspaceType;
+}
+
+export default class WorkspaceBase {
+  public static async sendPayloadBlocksToChannel(_data: {
+    authToken: string;
+    channelId: string;
+    blocks: Array<JSONObject>;
+  }): Promise<void> {
+    throw new NotImplementedException();
+  }
+
+  public static async inviteUsersToChannels(data: {
+    authToken: string;
+    workspaceChannelInvitationPayload: WorkspaceChannelInvitationPayload;
+  }): Promise<void> {
+    for (const channelName of data.workspaceChannelInvitationPayload
+      .channelNames) {
+      await this.inviteUsersToChannel({
+        authToken: data.authToken,
+        channelName: channelName,
+        workspaceUserIds:
+          data.workspaceChannelInvitationPayload.workspaceUserIds,
+      });
+    }
+  }
+
+  public static async inviteUsersToChannel(data: {
+    authToken: string;
+    channelName: string;
+    workspaceUserIds: Array<string>;
+  }): Promise<void> {
+    for (const userId of data.workspaceUserIds) {
+      await this.inviteUserToChannel({
+        authToken: data.authToken,
+        channelName: data.channelName,
+        workspaceUserId: userId,
+      });
+    }
+  }
+
+  public static async inviteUserToChannel(_data: {
+    authToken: string;
+    channelName: string;
+    workspaceUserId: string;
+  }): Promise<void> {
+    throw new NotImplementedException();
+  }
+
+  public static async createChannelsIfDoesNotExist(_data: {
+    authToken: string;
+    channelNames: Array<string>;
+  }): Promise<Array<WorkspaceChannel>> {
+    throw new NotImplementedException();
+  }
+
+  public static async getWorkspaceChannelFromChannelId(_data: {
+    authToken: string;
+    channelId: string;
+  }): Promise<WorkspaceChannel> {
+    throw new NotImplementedException();
+  }
+
+  public static async sendMessage(_data: {
+    workspaceMessagePayload: WorkspaceMessagePayload;
+    authToken: string; // which auth token should we use to send.
+  }): Promise<void> {
+    throw new NotImplementedException();
+  }
+
+  public static async getAllWorkspaceChannels(_data: {
+    authToken: string;
+  }): Promise<Dictionary<WorkspaceChannel>> {
+    throw new NotImplementedException();
+  }
+
+  public static async createChannel(_data: {
+    authToken: string;
+    channelName: string;
+  }): Promise<WorkspaceChannel> {
+    throw new NotImplementedException();
+  }
+
+  public static getHeaderBlock(_data: {
+    payloadHeaderBlock: WorkspacePayloadHeader;
+  }): JSONObject {
+    throw new NotImplementedException();
+  }
+
+  public static getMarkdownBlock(_data: {
+    payloadMarkdownBlock: WorkspacePayloadMarkdown;
+  }): JSONObject {
+    throw new NotImplementedException();
+  }
+
+  public static getButtonBlock(_data: {
+    payloadButtonBlock: WorkspaceMessagePayloadButton;
+  }): JSONObject {
+    throw new NotImplementedException();
+  }
+
+  public static getBlocksFromWorkspaceMessagePayload(
+    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;
+  }
+
+  public static async sendMessageToChannelViaIncomingWebhook(_data: {
+    url: URL;
+    text: string;
+  }): Promise<HTTPResponse<JSONObject> | HTTPErrorResponse> {
+    throw new NotImplementedException();
+  }
+}

package/Types/Workspace/NotificationRules/CreateChannelNotificationRule.ts

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

package/Types/Workspace/NotificationRules/NotificationRuleCondition.ts

@@ -83,21 +83,33 @@ export class NotificationRuleConditionUtil {
       }
     }
 
-    if (eventType === NotificationRuleEventType.Incident) {
+    if (
+      eventType === NotificationRuleEventType.Incident ||
+      eventType === NotificationRuleEventType.Alert ||
+      eventType === NotificationRuleEventType.ScheduledMaintenance
+    ) {
       // either create slack channel or select existing one should be active.
 
-      if (workspaceType === WorkspaceType.Slack) {
-        if (
-          !notificationRule.shouldCreateNewChannel &&
-          !notificationRule.shouldPostToExistingChannel
-        ) {
-          return "Please select either create slack channel or post to existing slack channel";
+      if (
+        !notificationRule.shouldCreateNewChannel &&
+        !notificationRule.shouldPostToExistingChannel
+      ) {
+        return (
+          "Please select either create slack channel or post to existing " +
+          workspaceType +
+          " channel"
+        );
+      }
+
+      if (notificationRule.shouldPostToExistingChannel) {
+        if (!notificationRule.existingChannelNames?.trim()) {
+          return "Existing " + workspaceType + " channel name is required";
         }
+      }
 
-        if (notificationRule.shouldPostToExistingChannel) {
-          if (!notificationRule.existingChannelNames?.trim()) {
-            return "Existing Slack channel name is required";
-          }
+      if (notificationRule.shouldCreateNewChannel) {
+        if (!notificationRule.newChannelTemplateName?.trim()) {
+          return "New " + workspaceType + " channel name is required";
         }
       }
     }

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

@@ -1,15 +1,8 @@
-import ObjectID from "../../../ObjectID";
-import BaseNotificationRule from "../BaseNotificationRule";
+import CreateChannelNotificationRule from "../CreateChannelNotificationRule";
 
-export default interface AlertNotificationRule extends BaseNotificationRule {
+export default interface AlertNotificationRule
+  extends CreateChannelNotificationRule {
   _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

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