@oneuptime/common 7.0.3717 → 7.0.3786

package/Server/Services/WorkspaceUserAuthTokenService.ts

@@ -10,6 +10,29 @@ export class Service extends DatabaseService<Model> {
     super(Model);
   }
 
+  public async getUserAuth(data: {
+    projectId: ObjectID;
+    userId: ObjectID;
+    workspaceType: WorkspaceType;
+  }): Promise<Model | null> {
+    return await this.findOneBy({
+      query: {
+        userId: data.userId,
+        projectId: data.projectId,
+        workspaceType: data.workspaceType,
+      },
+      select: {
+        authToken: true,
+        workspaceUserId: true,
+        miscData: true,
+        workspaceType: true,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+  }
+
   public async doesExist(data: {
     projectId: ObjectID;
     userId: ObjectID;

package/Server/Utils/Express.ts

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

package/Server/Utils/StartServer.ts

@@ -31,7 +31,6 @@ import Typeof from "Common/Types/Typeof";
 import CookieParser from "cookie-parser";
 import cors from "cors";
 import zlib from "zlib";
-
 // Make sure we have stack trace for debugging.
 Error.stackTraceLimit = Infinity;
 
@@ -50,6 +49,12 @@ const jsonBodyParserMiddleware: RequestHandler = ExpressJson({
 const urlEncodedMiddleware: RequestHandler = ExpressUrlEncoded({
   limit: "50mb",
   extended: true,
+  verify: (req: ExpressRequest, _res: ExpressResponse, buf: Buffer) => {
+    (req as OneUptimeRequest).rawFormUrlEncodedBody = buf.toString();
+    logger.debug(
+      `Raw Form Url Encoded Body: ${(req as OneUptimeRequest).rawFormUrlEncodedBody}`,
+    );
+  },
 }); // 50 MB limit.
 
 const setDefaultHeaders: RequestHandler = (

package/Server/Utils/Workspace/MicrosoftTeams/Messages/Incident.ts

@@ -0,0 +1,195 @@
+import Incident from "../../../../../Models/DatabaseModels/Incident";
+import BadDataException from "../../../../../Types/Exception/BadDataException";
+import {
+  WorkspaceMessageBlock,
+  WorkspaceMessagePayloadButton,
+  WorkspacePayloadButtons,
+  WorkspacePayloadDivider,
+  WorkspacePayloadHeader,
+  WorkspacePayloadMarkdown,
+} from "../../../../../Types/Workspace/WorkspaceMessagePayload";
+import IncidentService from "../../../../Services/IncidentService";
+import MonitorService from "../../../../Services/MonitorService";
+import SlackActionType from "../../../../Utils/Workspace/Slack/Actions/ActionTypes";
+
+export default class MicrosoftTeamsIncidentMessages {
+  public static async getIncidentCreateMessageBlocks(data: {
+    incident: Incident;
+  }): Promise<Array<WorkspaceMessageBlock>> {
+    const incident: Incident = data.incident;
+
+    if (!incident) {
+      throw new BadDataException("Incident not found");
+    }
+
+    // Slack.
+
+    const blockSlack: Array<WorkspaceMessageBlock> = [];
+
+    if (incident.incidentNumber) {
+      const markdownBlock1: WorkspacePayloadHeader = {
+        _type: "WorkspacePayloadHeader",
+        text: `:rotating_light: **Incident #${incident.incidentNumber}**`,
+      };
+      blockSlack.push(markdownBlock1);
+    }
+
+    if (incident.title) {
+      const markdownBlock2: WorkspacePayloadMarkdown = {
+        _type: "WorkspacePayloadMarkdown",
+        text: `**[${incident.title}](${(await IncidentService.getIncidentLinkInDashboard(incident.projectId!, incident.id!)).toString()})**`,
+      };
+      blockSlack.push(markdownBlock2);
+    }
+
+    if (incident.description) {
+      const markdownBlock3: WorkspacePayloadMarkdown = {
+        _type: "WorkspacePayloadMarkdown",
+        text: `${incident.description}`,
+      };
+      blockSlack.push(markdownBlock3);
+    }
+
+    if (incident.currentIncidentState?.name) {
+      const markdownBlock7: WorkspacePayloadMarkdown = {
+        _type: "WorkspacePayloadMarkdown",
+        text: `:arrow_right: **Incident State**: ${incident.currentIncidentState.name}`,
+      };
+      blockSlack.push(markdownBlock7);
+    }
+
+    if (incident.incidentSeverity?.name) {
+      const markdownBlock4: WorkspacePayloadMarkdown = {
+        _type: "WorkspacePayloadMarkdown",
+        text: `:warning: **Severity**: ${incident.incidentSeverity.name}`,
+      };
+      blockSlack.push(markdownBlock4);
+    }
+
+    // check for monitors.
+    if (incident.monitors && incident.monitors.length > 0) {
+      let text: string = `:earth_americas: *Resources Affected*:\n`;
+
+      for (const monitor of incident.monitors) {
+        text += `- [${monitor.name}](${(await MonitorService.getMonitorLinkInDashboard(incident.projectId!, monitor.id!)).toString()})\n`;
+      }
+
+      // now add text to markdwon block.
+      const markdownBlock5: WorkspacePayloadMarkdown = {
+        _type: "WorkspacePayloadMarkdown",
+        text: text,
+      };
+
+      blockSlack.push(markdownBlock5);
+    }
+
+    if (incident.rootCause) {
+      const markdownBlock5: WorkspacePayloadMarkdown = {
+        _type: "WorkspacePayloadMarkdown",
+        text: `:page_facing_up: **Root Cause**:
+        ${incident.rootCause}`,
+      };
+      blockSlack.push(markdownBlock5);
+    }
+
+    if (incident.remediationNotes) {
+      const markdownBlock6: WorkspacePayloadMarkdown = {
+        _type: "WorkspacePayloadMarkdown",
+        text: `:dart: **Remediation Notes**:
+        ${incident.remediationNotes}`,
+      };
+      blockSlack.push(markdownBlock6);
+    }
+
+    // add divider.
+
+    const dividerBlock: WorkspacePayloadDivider = {
+      _type: "WorkspacePayloadDivider",
+    };
+
+    blockSlack.push(dividerBlock);
+
+    // now add buttons.
+    // View Incident.
+    // Execute On Call
+    // Acknowledge incident
+    // Resolve Incident.
+    // Change Incident State.
+    // Add Note.
+
+    const buttons: Array<WorkspaceMessagePayloadButton> = [];
+
+    // view incident.
+    const viewIncidentButton: WorkspaceMessagePayloadButton = {
+      _type: "WorkspaceMessagePayloadButton",
+      title: "View Incident",
+      url: await IncidentService.getIncidentLinkInDashboard(
+        incident.projectId!,
+        incident.id!,
+      ),
+      value: "view_incident",
+      actionId: SlackActionType.ViewIncident,
+    };
+
+    buttons.push(viewIncidentButton);
+
+    // execute on call.
+    const executeOnCallButton: WorkspaceMessagePayloadButton = {
+      _type: "WorkspaceMessagePayloadButton",
+      title: ":telephone_receiver: Execute On Call",
+      value: "execute_on_call",
+      actionId: SlackActionType.ViewExecuteIncidentOnCallPolicy,
+    };
+
+    buttons.push(executeOnCallButton);
+
+    // acknowledge incident.
+    const acknowledgeIncidentButton: WorkspaceMessagePayloadButton = {
+      _type: "WorkspaceMessagePayloadButton",
+      title: ":eyes: Acknowledge Incident",
+      value: "acknowledge_incident",
+      actionId: SlackActionType.AcknowledgeIncident,
+    };
+
+    buttons.push(acknowledgeIncidentButton);
+
+    // resolve incident.
+    const resolveIncidentButton: WorkspaceMessagePayloadButton = {
+      _type: "WorkspaceMessagePayloadButton",
+      title: ":white_check_mark: Resolve Incident",
+      value: "resolve_incident",
+      actionId: SlackActionType.ResolveIncident,
+    };
+
+    buttons.push(resolveIncidentButton);
+
+    // change incident state.
+    const changeIncidentStateButton: WorkspaceMessagePayloadButton = {
+      _type: "WorkspaceMessagePayloadButton",
+      title: ":arrow_right: Change Incident State",
+      value: "change_incident_state",
+      actionId: SlackActionType.ViewChangeIncidentState,
+    };
+
+    buttons.push(changeIncidentStateButton);
+
+    // add note.
+    const addNoteButton: WorkspaceMessagePayloadButton = {
+      _type: "WorkspaceMessagePayloadButton",
+      title: ":page_facing_up: Add Note",
+      value: "add_note",
+      actionId: SlackActionType.ViewAddIncidentNote,
+    };
+
+    buttons.push(addNoteButton);
+
+    const workspacePayloadButtons: WorkspacePayloadButtons = {
+      buttons: buttons,
+      _type: "WorkspacePayloadButtons",
+    };
+
+    blockSlack.push(workspacePayloadButtons);
+
+    return blockSlack;
+  }
+}

package/Server/Utils/Workspace/Slack/Actions/ActionTypes.ts

@@ -0,0 +1,20 @@
+enum SlackActionType {
+  // Incident actions
+  AcknowledgeIncident = "AcknowledgeIncident",
+  ResolveIncident = "ResolveIncident",
+  ViewAddIncidentNote = "ViewAddIncidentNote",
+  SubmitIncidentNote = "SubmitIncidentNote",
+  ViewChangeIncidentState = "ViewChangeIncidentState",
+  SubmitChangeIncidentState = "SubmitChangeIncidentState",
+  ViewExecuteIncidentOnCallPolicy = "ViewExecuteIncidentOnCallPolicy",
+  SubmitExecuteIncidentOnCallPolicy = "SubmitExecuteIncidentOnCallPolicy",
+  ViewIncident = "ViewIncident",
+  NewIncident = "/incident", // new incident slash command
+  SubmitNewIncident = "SubmitNewIncident",
+
+  // Alert Actions
+
+  // Scheduled Maintenance Actions.
+}
+
+export default SlackActionType;

package/Server/Utils/Workspace/Slack/Actions/Auth.ts

@@ -0,0 +1,266 @@
+import WorkspaceProjectAuthToken, {
+  SlackMiscData,
+} from "../../../../../Models/DatabaseModels/WorkspaceProjectAuthToken";
+import WorkspaceUserAuthToken from "../../../../../Models/DatabaseModels/WorkspaceUserAuthToken";
+import ObjectID from "../../../../../Types/ObjectID";
+import { WorkspacePayloadMarkdown } from "../../../../../Types/Workspace/WorkspaceMessagePayload";
+import WorkspaceUserAuthTokenService from "../../../../Services/WorkspaceUserAuthTokenService";
+import { ExpressRequest } from "../../../Express";
+import SlackUtil from "../Slack";
+import SlackActionType from "./ActionTypes";
+import WorkspaceProjectAuthTokenService from "../../../../Services/WorkspaceProjectAuthTokenService";
+import logger from "../../../Logger";
+import { JSONArray, JSONObject } from "../../../../../Types/JSON";
+import { Dictionary } from "lodash";
+
+export interface SlackAction {
+  actionValue?: string | undefined;
+  actionType?: SlackActionType | undefined;
+}
+
+export interface SlackRequest {
+  isAuthorized: boolean;
+  userId?: ObjectID | undefined;
+  projectId?: ObjectID | undefined;
+  projectAuthToken?: string | undefined;
+  userAuthToken?: string | undefined;
+  botUserId?: string | undefined;
+  slackChannelId?: string | undefined;
+  slackMessageId?: string | undefined;
+  slackUserFullName?: string | undefined;
+  slackUserId?: string | undefined;
+  slackUsername?: string | undefined;
+  actions?: SlackAction[] | undefined;
+  triggerId?: string | undefined;
+  view?: JSONObject | undefined; // view object from slack.
+  viewValues?: Dictionary<string | number | Array<string | number>> | undefined;
+}
+
+export default class SlackAuthAction {
+  public static async isAuthorized(data: {
+    req: ExpressRequest;
+  }): Promise<SlackRequest> {
+    const { req } = data;
+
+    logger.debug("Starting Slack request authorization");
+    logger.debug(`Request body: `);
+    logger.debug(req.body);
+
+    let payload: JSONObject = req.body;
+
+    if (payload["payload"] && typeof payload["payload"] === "string") {
+      payload = JSON.parse(payload["payload"]);
+    }
+
+    logger.debug(`Payload: `);
+    logger.debug(payload);
+
+    let slackUserId: string | undefined = (
+      (payload as JSONObject)["user"] as JSONObject
+    )?.["id"] as string;
+    let slackTeamId: string | undefined = (
+      (payload as JSONObject)["team"] as JSONObject
+    )?.["id"] as string;
+
+    // if there are no actions then return.
+    if (
+      (!payload["actions"] || (payload["actions"] as JSONArray).length === 0) &&
+      payload["type"] !== "view_submission" &&
+      payload["type"] !== "shortcut" &&
+      !payload["command"]
+    ) {
+      logger.debug("No actions found in payload. Returning unauthorized.");
+      return {
+        isAuthorized: false,
+      };
+    }
+
+    const actions: SlackAction[] = (
+      (payload["actions"] || []) as JSONArray
+    ).map((action: JSONObject) => {
+      return {
+        actionValue: action["value"] as string,
+        actionType: action["action_id"] as SlackActionType,
+      };
+    });
+
+    let slackChannelId: string | undefined = (
+      (payload as JSONObject)?.["channel"] as JSONObject
+    )?.["id"] as string;
+
+    if (!slackChannelId) {
+      slackChannelId = (payload as JSONObject)?.["channel_id"] as string;
+    }
+
+    const slackMessageId: string | undefined = (
+      (payload as JSONObject)?.["message"] as JSONObject
+    )?.["ts"] as string;
+
+    const slackUserFullName: string | undefined = (
+      (payload as JSONObject)?.["user"] as JSONObject
+    )?.["name"] as string;
+
+    let slackUsername: string | undefined = (
+      (payload as JSONObject)?.["user"] as JSONObject
+    )?.["username"] as string;
+
+    if (payload["user_id"]) {
+      slackUserId = payload["user_id"] as string;
+    }
+
+    if (payload["user_name"]) {
+      slackUsername = payload["user_name"] as string;
+    }
+
+    if (payload["team_id"]) {
+      slackTeamId = payload["team_id"] as string;
+    }
+
+    const triggerId: string | undefined = payload?.["trigger_id"] as string;
+
+    const projectAuth: WorkspaceProjectAuthToken | null =
+      await WorkspaceProjectAuthTokenService.findOneBy({
+        query: {
+          workspaceProjectId: slackTeamId,
+        },
+        select: {
+          projectId: true,
+          authToken: true,
+          miscData: true,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+    if (!projectAuth) {
+      return {
+        isAuthorized: false,
+      };
+    }
+
+    const projectId: ObjectID | undefined = projectAuth.projectId;
+
+    if (!projectId) {
+      logger.debug(
+        "Project ID not found in project auth. Returning unauthorized.",
+      );
+      return {
+        isAuthorized: false,
+      };
+    }
+
+    const userAuth: WorkspaceUserAuthToken | null =
+      await WorkspaceUserAuthTokenService.findOneBy({
+        query: {
+          workspaceUserId: slackUserId,
+          projectId: projectId,
+        },
+        select: {
+          userId: true,
+          authToken: true,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+    const botUserId: string | undefined = (
+      projectAuth.miscData as SlackMiscData
+    )?.botUserId;
+
+    const userId: ObjectID | undefined = userAuth?.userId;
+
+    if (!userAuth || !userId) {
+      const markdwonPayload: WorkspacePayloadMarkdown = {
+        _type: "WorkspacePayloadMarkdown",
+        text: `@${slackUsername}, Unfortunately your slack account is not connected to OneUptime. Please log into your OneUptime account, click on User Settings and then connect your Slack account. `,
+      };
+
+      await SlackUtil.sendDirectMessageToUser({
+        authToken: projectAuth.authToken!,
+        workspaceUserId: slackUserId,
+        messageBlocks: [markdwonPayload],
+      });
+
+      // clear response.
+      logger.debug("User auth not found. Returning unauthorized.");
+
+      return {
+        isAuthorized: false,
+      };
+    }
+
+    const view: JSONObject | undefined =
+      (payload["view"] as JSONObject) || undefined;
+
+    let viewValues: Dictionary<string | number | Array<string | number>> = {};
+
+    if (view) {
+      viewValues = SlackUtil.getValuesFromView({
+        view: view,
+      });
+
+      // add actionId and actionValue
+
+      const action: SlackAction = {
+        // view callbackId
+        actionType: view["callback_id"] as SlackActionType,
+        // private metadata
+        actionValue: view["private_metadata"]?.toString(),
+      };
+
+      actions.push(action);
+      logger.debug("View values: ");
+      logger.debug(viewValues);
+
+      logger.debug("Actions: ");
+      logger.debug(actions);
+    }
+
+    if (payload["callback_id"]) {
+      const action: SlackAction = {
+        actionType: payload["callback_id"] as SlackActionType,
+      };
+
+      actions.push(action);
+    }
+
+    const command: string | undefined = payload["command"] as string;
+    const commandText: string | undefined = payload["text"] as string;
+
+    // add command to actions.
+    if (command) {
+      const action: SlackAction = {
+        actionType: command as SlackActionType,
+        actionValue: commandText,
+      };
+
+      actions.push(action);
+    }
+
+    const slackRequest: SlackRequest = {
+      isAuthorized: true,
+      slackUserId: slackUserId,
+      userId: userId,
+      projectId: projectId,
+      projectAuthToken: projectAuth.authToken!,
+      userAuthToken: userAuth.authToken!,
+      botUserId: botUserId,
+      slackChannelId: slackChannelId,
+      slackUsername: slackUsername,
+      slackMessageId: slackMessageId,
+      slackUserFullName: slackUserFullName,
+      actions: actions,
+      triggerId: triggerId,
+      view: view,
+      viewValues: viewValues,
+    };
+
+    logger.debug("Slack request authorized successfully");
+    logger.debug("Slack request: ");
+    logger.debug(slackRequest);
+
+    return slackRequest;
+  }
+}