@oneuptime/common 7.0.3621 → 7.0.3655

package/Server/Services/WorkspaceProjectAuthTokenService.ts

@@ -0,0 +1,84 @@
+import ObjectID from "../../Types/ObjectID";
+import WorkspaceType from "../../Types/Workspace/WorkspaceType";
+import DatabaseService from "./DatabaseService";
+import Model, {
+  SlackMiscData,
+} from "Common/Models/DatabaseModels/WorkspaceProjectAuthToken";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+  }
+
+  public async doesExist(data: {
+    projectId: ObjectID;
+    workspaceType: WorkspaceType;
+  }): Promise<boolean> {
+    return (
+      (
+        await this.countBy({
+          query: {
+            projectId: data.projectId,
+            workspaceType: data.workspaceType,
+          },
+          skip: 0,
+          limit: 1,
+          props: {
+            isRoot: true,
+          },
+        })
+      ).toNumber() > 0
+    );
+  }
+
+  public async refreshAuthToken(data: {
+    projectId: ObjectID;
+    workspaceType: WorkspaceType;
+    authToken: string;
+    workspaceProjectId: string;
+    miscData: SlackMiscData;
+  }): Promise<void> {
+    let projectAuth: Model | null = await this.findOneBy({
+      query: {
+        projectId: data.projectId,
+        workspaceType: data.workspaceType,
+      },
+      select: {
+        _id: true,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    if (!projectAuth) {
+      projectAuth = new Model();
+
+      projectAuth.projectId = data.projectId;
+      projectAuth.authToken = data.authToken;
+      projectAuth.workspaceType = data.workspaceType;
+      projectAuth.workspaceProjectId = data.workspaceProjectId;
+      projectAuth.miscData = data.miscData;
+
+      await this.create({
+        data: projectAuth,
+        props: {
+          isRoot: true,
+        },
+      });
+    } else {
+      await this.updateOneById({
+        id: projectAuth.id!,
+        data: {
+          authToken: data.authToken,
+          workspaceProjectId: data.workspaceProjectId,
+          miscData: data.miscData,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+    }
+  }
+}
+export default new Service();

package/Server/Services/WorkspaceSettingService.ts

@@ -0,0 +1,78 @@
+import ObjectID from "../../Types/ObjectID";
+import WorkspaceType from "../../Types/Workspace/WorkspaceType";
+import DatabaseService from "./DatabaseService";
+import Model, {
+  SlackSettings,
+} from "Common/Models/DatabaseModels/WorkspaceSetting";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+  }
+
+  public async doesExist(data: {
+    projectId: ObjectID;
+    workspaceType: WorkspaceType;
+  }): Promise<boolean> {
+    return (
+      (
+        await this.countBy({
+          query: {
+            projectId: data.projectId,
+            workspaceType: data.workspaceType,
+          },
+          skip: 0,
+          limit: 1,
+          props: {
+            isRoot: true,
+          },
+        })
+      ).toNumber() > 0
+    );
+  }
+
+  public async refreshSetting(data: {
+    projectId: ObjectID;
+    workspaceType: WorkspaceType;
+    settings: SlackSettings;
+  }): Promise<void> {
+    let workspaceSetting: Model | null = await this.findOneBy({
+      query: {
+        projectId: data.projectId,
+        workspaceType: data.workspaceType,
+      },
+      select: {
+        _id: true,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    if (!workspaceSetting) {
+      workspaceSetting = new Model();
+
+      workspaceSetting.projectId = data.projectId;
+      workspaceSetting.settings = data.settings;
+      workspaceSetting.workspaceType = data.workspaceType;
+
+      await this.create({
+        data: workspaceSetting,
+        props: {
+          isRoot: true,
+        },
+      });
+    } else {
+      await this.updateOneById({
+        id: workspaceSetting.id!,
+        data: {
+          settings: data.settings,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+    }
+  }
+}
+export default new Service();

package/Server/Services/WorkspaceUserAuthTokenService.ts

@@ -0,0 +1,89 @@
+import ObjectID from "../../Types/ObjectID";
+import WorkspaceType from "../../Types/Workspace/WorkspaceType";
+import DatabaseService from "./DatabaseService";
+import Model, {
+  SlackMiscData,
+} from "Common/Models/DatabaseModels/WorkspaceUserAuthToken";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+  }
+
+  public async doesExist(data: {
+    projectId: ObjectID;
+    userId: ObjectID;
+    workspaceType: WorkspaceType;
+  }): Promise<boolean> {
+    return (
+      (
+        await this.countBy({
+          query: {
+            projectId: data.projectId,
+            userId: data.userId,
+            workspaceType: data.workspaceType,
+          },
+          skip: 0,
+          limit: 1,
+          props: {
+            isRoot: true,
+          },
+        })
+      ).toNumber() > 0
+    );
+  }
+
+  public async refreshAuthToken(data: {
+    projectId: ObjectID;
+    userId: ObjectID;
+    workspaceType: WorkspaceType;
+    authToken: string;
+    workspaceUserId: string;
+    miscData: SlackMiscData;
+  }): Promise<void> {
+    let userAuth: Model | null = await this.findOneBy({
+      query: {
+        projectId: data.projectId,
+        userId: data.userId,
+        workspaceType: data.workspaceType,
+      },
+      select: {
+        _id: true,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    if (!userAuth) {
+      userAuth = new Model();
+
+      userAuth.projectId = data.projectId;
+      userAuth.userId = data.userId;
+      userAuth.authToken = data.authToken;
+      userAuth.workspaceType = data.workspaceType;
+      userAuth.workspaceUserId = data.workspaceUserId;
+      userAuth.miscData = data.miscData;
+
+      await this.create({
+        data: userAuth,
+        props: {
+          isRoot: true,
+        },
+      });
+    } else {
+      await this.updateOneById({
+        id: userAuth.id!,
+        data: {
+          authToken: data.authToken,
+          workspaceUserId: data.workspaceUserId,
+          miscData: data.miscData,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+    }
+  }
+}
+export default new Service();

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

@@ -8,7 +8,7 @@ import { JSONObject } from "Common/Types/JSON";
 import ComponentMetadata, { Port } from "Common/Types/Workflow/Component";
 import ComponentID from "Common/Types/Workflow/ComponentID";
 import SlackComponents from "Common/Types/Workflow/Components/Slack";
-import SlackUtil from "../../../../Utils/Slack";
+import SlackUtil from "../../../../Utils/Slack/Slack";
 
 export default class SendMessageToChannel extends ComponentCode {
   public constructor() {
@@ -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/Express.ts

@@ -37,7 +37,8 @@ export interface OneUptimeRequest extends express.Request {
   userAuthorization?: JSONWebTokenData;
   tenantId?: ObjectID;
   userGlobalAccessPermission?: UserGlobalAccessPermission;
-  userTenantAccessPermission?: Dictionary<UserTenantAccessPermission>; // tenantId <-> UserTenantAccessPermission
+  userTenantAccessPermission?: Dictionary<UserTenantAccessPermission>; // tenantId <-> UserTenantAccessPermission;
+  rawBody?: string; // raw body of the request before json parsing.
 }
 
 export interface OneUptimeResponse extends express.Response {

package/Server/Utils/Monitor/MonitorResource.ts

@@ -16,11 +16,7 @@ import BadDataException from "Common/Types/Exception/BadDataException";
 import BasicInfrastructureMetrics from "Common/Types/Infrastructure/BasicMetrics";
 import ReturnResult from "Common/Types/IsolatedVM/ReturnResult";
 import { JSONObject } from "Common/Types/JSON";
-import {
-  CheckOn,
-  CriteriaFilter,
-  FilterCondition,
-} from "Common/Types/Monitor/CriteriaFilter";
+import { CheckOn, CriteriaFilter } from "Common/Types/Monitor/CriteriaFilter";
 import IncomingMonitorRequest from "Common/Types/Monitor/IncomingMonitor/IncomingMonitorRequest";
 import MonitorCriteria from "Common/Types/Monitor/MonitorCriteria";
 import MonitorCriteriaInstance from "Common/Types/Monitor/MonitorCriteriaInstance";
@@ -57,6 +53,7 @@ import MonitorMetricType from "../../../Types/Monitor/MonitorMetricType";
 import TelemetryUtil from "../Telemetry/Telemetry";
 import MetricMonitorCriteria from "./Criteria/MetricMonitorCriteria";
 import MetricMonitorResponse from "../../../Types/Monitor/MetricMonitor/MetricMonitorResponse";
+import FilterCondition from "../../../Types/Filter/FilterCondition";
 
 export default class MonitorResourceUtil {
   public static async monitorResource(

package/Server/Utils/Slack/Slack.ts

@@ -0,0 +1,271 @@
+import HTTPErrorResponse from "Common/Types/API/HTTPErrorResponse";
+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 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,
+        },
+        {
+          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.payloadHeaderBlock.text,
+      },
+    };
+  }
+
+  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.payloadButtonBlock.title,
+      },
+      value: data.payloadButtonBlock.title,
+      action_id: data.payloadButtonBlock.title,
+    };
+  }
+
+  public static async sendMessageToChannelViaIncomingWebhook(data: {
+    url: URL;
+    text: string;
+  }): Promise<HTTPResponse<JSONObject> | HTTPErrorResponse> {
+    let apiResult: HTTPResponse<JSONObject> | HTTPErrorResponse | null = null;
+
+    // https://api.slack.com/messaging/webhooks#advanced_message_formatting
+    apiResult = await API.post(data.url, {
+      blocks: [
+        {
+          type: "section",
+          text: {
+            type: "mrkdwn",
+            text: `${data.text}`,
+          },
+        },
+      ],
+    });
+
+    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;
+  }
+}