@oneuptime/common 7.0.5014 → 7.0.5020

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

@@ -3,414 +3,154 @@ import HTTPResponse from "../../../../Types/API/HTTPResponse";
 import URL from "../../../../Types/API/URL";
 import { JSONObject } from "../../../../Types/JSON";
 import API from "../../../../Utils/API";
-import WorkspaceMessagePayload from "../../../../Types/Workspace/WorkspaceMessagePayload";
 import logger from "../../Logger";
-import Dictionary from "../../../../Types/Dictionary";
-import WorkspaceBase, {
-  WorkspaceChannel,
-  WorkspaceSendMessageResponse,
-  WorkspaceThread,
-} from "../WorkspaceBase";
-import WorkspaceType from "../../../../Types/Workspace/WorkspaceType";
-import OneUptimeDate from "../../../../Types/Date";
+import WorkspaceBase from "../WorkspaceBase";
 import CaptureSpan from "../../Telemetry/CaptureSpan";
-import BadDataException from "../../../../Types/Exception/BadDataException";
 
 export default class MicrosoftTeams extends WorkspaceBase {
-  @CaptureSpan()
-  public static override async getAllWorkspaceChannels(data: {
-    authToken: string;
-  }): Promise<Dictionary<WorkspaceChannel>> {
-    logger.debug("Getting all workspace channels with data:");
-    logger.debug(data);
-
-    const channels: Dictionary<WorkspaceChannel> = {};
-    const response: HTTPErrorResponse | HTTPResponse<JSONObject> =
-      await API.get<JSONObject>(
-        URL.fromString("https://graph.microsoft.com/v1.0/me/joinedTeams"),
-        {
-          Authorization: `Bearer ${data.authToken}`,
-        },
-      );
-
-    logger.debug("Response from Microsoft Graph API for getting all channels:");
-    logger.debug(JSON.stringify(response, null, 2));
-
-    if (response instanceof HTTPErrorResponse) {
-      logger.error("Error response from Microsoft Graph API:");
-      logger.error(response);
-      throw response;
-    }
-
-    for (const team of (response.jsonData as JSONObject)?.[
-      "value"
-    ] as Array<JSONObject>) {
-      if (!team["id"] || !team["displayName"]) {
-        continue;
-      }
-
-      channels[team["displayName"].toString()] = {
-        id: team["id"] as string,
-        name: team["displayName"] as string,
-        workspaceType: WorkspaceType.MicrosoftTeams,
-      };
-    }
-
-    logger.debug("All workspace channels obtained:");
-    logger.debug(channels);
-    return channels;
-  }
-
-  @CaptureSpan()
-  public static override getDividerBlock(): JSONObject {
-    return {
-      type: "divider",
-    };
-  }
-
-  @CaptureSpan()
-  public static getValuesFromView(data: {
-    view: JSONObject;
-  }): Dictionary<string | number | Array<string | number> | Date> {
-    logger.debug("Getting values from view with data:");
-    logger.debug(JSON.stringify(data, null, 2));
-
-    const teamsView: JSONObject = data.view;
-    const values: Dictionary<string | number | Array<string | number> | Date> =
-      {};
-
-    if (!teamsView["state"] || !(teamsView["state"] as JSONObject)["values"]) {
-      return {};
-    }
-
-    for (const valueId in (teamsView["state"] as JSONObject)[
-      "values"
-    ] as JSONObject) {
-      for (const blockId in (
-        (teamsView["state"] as JSONObject)["values"] as JSONObject
-      )[valueId] as JSONObject) {
-        const valueObject: JSONObject = (
-          (teamsView["state"] as JSONObject)["values"] as JSONObject
-        )[valueId] as JSONObject;
-        const value: JSONObject = valueObject[blockId] as JSONObject;
-        values[blockId] = value["value"] as string | number;
-
-        if ((value["selected_option"] as JSONObject)?.["value"]) {
-          values[blockId] = (value["selected_option"] as JSONObject)?.[
-            "value"
-          ] as string;
-        }
-
-        if (Array.isArray(value["selected_options"])) {
-          values[blockId] = (
-            value["selected_options"] as Array<JSONObject>
-          ).map((option: JSONObject) => {
-            return option["value"] as string | number;
-          });
-        }
-
-        // if date picker
-        if (value["selected_date_time"]) {
-          values[blockId] = OneUptimeDate.fromUnixTimestamp(
-            value["selected_date_time"] as number,
-          );
-        }
-      }
-    }
-
-    logger.debug("Values obtained from view:");
-    logger.debug(values);
-
-    return values;
-  }
-
-  @CaptureSpan()
-  public static override async inviteUserToChannelByChannelName(data: {
-    authToken: string;
-    channelName: string;
-    workspaceUserId: string;
-  }): Promise<void> {
-    logger.debug("Inviting user to channel with data:");
-    logger.debug(data);
-
-    const channelId: string = (
-      await this.getWorkspaceChannelFromChannelName({
-        authToken: data.authToken,
-        channelName: data.channelName,
+  private static buildMessageCardFromMarkdown(markdown: string): JSONObject {
+    // Teams MessageCard has limited markdown support. Headings like '##' are not supported
+    // and single newlines can collapse. Convert common patterns to a structured card.
+    const lines: Array<string> = markdown
+      .split("\n")
+      .map((l: string) => {
+        return l.trim();
       })
-    ).id;
-
-    return this.inviteUserToChannelByChannelId({
-      authToken: data.authToken,
-      channelId: channelId,
-      workspaceUserId: data.workspaceUserId,
-    });
-  }
-
-  @CaptureSpan()
-  public static override async createChannelsIfDoesNotExist(data: {
-    authToken: string;
-    channelNames: Array<string>;
-  }): Promise<Array<WorkspaceChannel>> {
-    logger.debug("Creating channels if they do not exist with data:");
-    logger.debug(data);
-
-    const workspaceChannels: Array<WorkspaceChannel> = [];
-    const existingWorkspaceChannels: Dictionary<WorkspaceChannel> =
-      await this.getAllWorkspaceChannels({
-        authToken: data.authToken,
+      .filter((l: string) => {
+        return l.length > 0;
       });
 
-    logger.debug("Existing workspace channels:");
-    logger.debug(existingWorkspaceChannels);
-
-    for (let channelName of data.channelNames) {
-      // if channel name starts with #, remove it
-      if (channelName && channelName.startsWith("#")) {
-        channelName = channelName.substring(1);
-      }
-
-      // convert channel name to lowercase
-      channelName = channelName.toLowerCase();
-
-      // replace spaces with hyphens
-      channelName = channelName.replace(/\s+/g, "-");
+    let title: string = "";
+    const facts: Array<JSONObject> = [];
+    const actions: Array<JSONObject> = [];
+    const bodyTextParts: Array<string> = [];
+
+    // Extract title from the first non-empty line and strip markdown heading markers
+    if (lines.length > 0) {
+      const firstLine: string = lines[0] ?? "";
+      title = firstLine
+        .replace(/^#+\s*/, "") // remove leading markdown headers like ##
+        .replace(/^\*\*|\*\*$/g, "") // remove stray bold markers if any
+        .trim();
+      lines.shift();
+    }
 
-      if (existingWorkspaceChannels[channelName]) {
-        logger.debug(`Channel ${channelName} already exists.`);
-        workspaceChannels.push(existingWorkspaceChannels[channelName]!);
-        continue;
+    const linkRegex: RegExp = /\[([^\]]+)\]\(([^)]+)\)/g; // [text](url)
+
+    for (const line of lines) {
+      // Extract links to actions and strip them from text
+      let lineWithoutLinks: string = line;
+      let match: RegExpExecArray | null = null;
+      while ((match = linkRegex.exec(line))) {
+        const name: string = match[1] ?? "";
+        const url: string = match[2] ?? "";
+        actions.push({
+          ["@type"]: "OpenUri",
+          name: name,
+          targets: [
+            {
+              os: "default",
+              uri: url,
+            },
+          ],
+        });
+        lineWithoutLinks = lineWithoutLinks.replace(match[0], "").trim();
       }
 
-      logger.debug(`Channel ${channelName} does not exist. Creating channel.`);
-      const channel: WorkspaceChannel = await this.createChannel({
-        authToken: data.authToken,
-        channelName: channelName,
-      });
+      // Parse facts of the form **Label:** value
+      const factMatch: RegExpExecArray | null = /\*\*(.*?)\:\*\*\s*(.*)/.exec(
+        lineWithoutLinks,
+      );
 
-      if (channel) {
-        logger.debug(`Channel ${channelName} created successfully.`);
-        workspaceChannels.push(channel);
+      if (factMatch) {
+        const name: string = (factMatch[1] ?? "").trim();
+        const value: string = (factMatch[2] ?? "").trim();
+        if (
+          name.toLowerCase() === "description" ||
+          name.toLowerCase() === "note"
+        ) {
+          bodyTextParts.push(`**${name}:** ${value}`);
+        } else {
+          facts.push({ name: name, value: value });
+        }
+      } else if (lineWithoutLinks) {
+        bodyTextParts.push(lineWithoutLinks);
       }
     }
 
-    logger.debug("Channels created or found:");
-    logger.debug(workspaceChannels);
-    return workspaceChannels;
-  }
-
-  @CaptureSpan()
-  public static override async getWorkspaceChannelFromChannelName(data: {
-    authToken: string;
-    channelName: string;
-  }): Promise<WorkspaceChannel> {
-    logger.debug("Getting workspace channel ID from channel name with data:");
-    logger.debug(data);
-
-    const channels: Dictionary<WorkspaceChannel> =
-      await this.getAllWorkspaceChannels({
-        authToken: data.authToken,
-      });
-
-    logger.debug("All workspace channels:");
-    logger.debug(channels);
+    const payload: JSONObject = {
+      ["@type"]: "MessageCard",
+      ["@context"]: "https://schema.org/extensions",
+      title: title,
+      summary: title,
+    };
 
-    if (!channels[data.channelName]) {
-      logger.error("Channel not found.");
-      throw new BadDataException("Channel not found.");
+    if (bodyTextParts.length > 0) {
+      payload["text"] = bodyTextParts.join("\n\n");
     }
 
-    logger.debug("Workspace channel ID obtained:");
-    logger.debug(channels[data.channelName]!.id);
-
-    return channels[data.channelName]!;
-  }
-
-  @CaptureSpan()
-  public static override async getWorkspaceChannelFromChannelId(data: {
-    authToken: string;
-    channelId: string;
-  }): Promise<WorkspaceChannel> {
-    logger.debug("Getting workspace channel from channel ID with data:");
-    logger.debug(data);
-
-    const response: HTTPErrorResponse | HTTPResponse<JSONObject> =
-      await API.get<JSONObject>(
-        URL.fromString(
-          `https://graph.microsoft.com/v1.0/teams/${data.channelId}`,
-        ),
+    if (facts.length > 0) {
+      payload["sections"] = [
         {
-          Authorization: `Bearer ${data.authToken}`,
+          facts: facts,
         },
-      );
-
-    logger.debug("Response from Microsoft Graph API for getting channel info:");
-    logger.debug(response);
-
-    if (response instanceof HTTPErrorResponse) {
-      logger.error("Error response from Microsoft Graph API:");
-      logger.error(response);
-      throw response;
+      ];
     }
 
-    if (!(response.jsonData as JSONObject)?.["displayName"]) {
-      logger.error("Invalid response from Microsoft Graph API:");
-      logger.error(response.jsonData);
-      throw new Error("Invalid response");
+    if (actions.length > 0) {
+      payload["potentialAction"] = actions;
     }
 
-    const channel: WorkspaceChannel = {
-      name: (response.jsonData as JSONObject)["displayName"] as string,
-      id: data.channelId,
-      workspaceType: WorkspaceType.MicrosoftTeams,
-    };
-
-    logger.debug("Workspace channel obtained:");
-    logger.debug(channel);
-    return channel;
+    return payload;
   }
 
   @CaptureSpan()
-  public static override async doesChannelExist(data: {
-    authToken: string;
-    channelName: string;
-  }): Promise<boolean> {
-    // if channel name starts with #, remove it
-    if (data.channelName && data.channelName.startsWith("#")) {
-      data.channelName = data.channelName.substring(1);
-    }
-
-    // convert channel name to lowercase
-    data.channelName = data.channelName.toLowerCase();
-
-    // get channel id from channel name
-    const channels: Dictionary<WorkspaceChannel> =
-      await this.getAllWorkspaceChannels({
-        authToken: data.authToken,
-      });
-
-    // if this channel exists
-    if (channels[data.channelName]) {
-      return true;
-    }
-
-    return false;
-  }
-
-  @CaptureSpan()
-  public static override async sendMessage(data: {
-    workspaceMessagePayload: WorkspaceMessagePayload;
-    authToken: string; // which auth token should we use to send.
-    userId: string;
-  }): Promise<WorkspaceSendMessageResponse> {
-    logger.debug("Sending message to Microsoft Teams with data:");
+  public static override async sendMessageToChannelViaIncomingWebhook(data: {
+    url: URL;
+    text: string;
+  }): Promise<HTTPResponse<JSONObject> | HTTPErrorResponse> {
+    logger.debug("Sending message to Teams channel via incoming webhook:");
     logger.debug(data);
 
-    const blocks: Array<JSONObject> = this.getBlocksFromWorkspaceMessagePayload(
-      data.workspaceMessagePayload,
-    );
-
-    logger.debug("Blocks generated from workspace message payload:");
-    logger.debug(blocks);
-
-    const existingWorkspaceChannels: Dictionary<WorkspaceChannel> =
-      await this.getAllWorkspaceChannels({
-        authToken: data.authToken,
-      });
-
-    logger.debug("Existing workspace channels:");
-    logger.debug(existingWorkspaceChannels);
-
-    const workspaceChannelsToPostTo: Array<WorkspaceChannel> = [];
-
-    for (let channelName of data.workspaceMessagePayload.channelNames) {
-      if (channelName && channelName.startsWith("#")) {
-        // trim # from channel name
-        channelName = channelName.substring(1);
-      }
-
-      let channel: WorkspaceChannel | null = null;
+    // Build a structured MessageCard from markdown for better rendering in Teams
+    const payload: JSONObject = this.buildMessageCardFromMarkdown(data.text);
 
-      if (existingWorkspaceChannels[channelName]) {
-        channel = existingWorkspaceChannels[channelName]!;
-      }
+    const apiResult: HTTPResponse<JSONObject> | HTTPErrorResponse | null =
+      await API.post(data.url, payload);
 
-      if (channel) {
-        workspaceChannelsToPostTo.push(channel);
-      } else {
-        logger.debug(`Channel ${channelName} does not exist.`);
-      }
+    if (!apiResult) {
+      logger.error(
+        "Could not send message to Teams channel via incoming webhook.",
+      );
+      throw new Error(
+        "Could not send message to Teams channel via incoming webhook.",
+      );
     }
 
-    // add channel ids.
-    for (const channelId of data.workspaceMessagePayload.channelIds) {
-      try {
-        // Get the channel info including name from channel ID
-        const channel: WorkspaceChannel =
-          await this.getWorkspaceChannelFromChannelId({
-            authToken: data.authToken,
-            channelId: channelId,
-          });
-
-        workspaceChannelsToPostTo.push(channel);
-      } catch (err) {
-        logger.error(`Error getting channel info for channel ID ${channelId}:`);
-        logger.error(err);
-
-        // Fallback: create channel object with empty name if API call fails
-        const channel: WorkspaceChannel = {
-          id: channelId,
-          name: channelId,
-          workspaceType: WorkspaceType.MicrosoftTeams,
-        };
-
-        workspaceChannelsToPostTo.push(channel);
-      }
+    if (apiResult instanceof HTTPErrorResponse) {
+      logger.error(
+        "Error sending message to Teams channel via incoming webhook:",
+      );
+      logger.error(apiResult);
+      throw apiResult;
     }
 
-    logger.debug("Channel IDs to post to:");
-    logger.debug(workspaceChannelsToPostTo);
-
-    const workspaceMessageResponse: WorkspaceSendMessageResponse = {
-      threads: [],
-      workspaceType: WorkspaceType.MicrosoftTeams,
-    };
-
-    for (const channel of workspaceChannelsToPostTo) {
-      try {
-        // check if the user is in the channel.
-        const isUserInChannel: boolean = await this.isUserInChannel({
-          authToken: data.authToken,
-          channelId: channel.id,
-          userId: data.userId,
-        });
-
-        if (!isUserInChannel) {
-          // add user to the channel
-          await this.joinChannel({
-            authToken: data.authToken,
-            channelId: channel.id,
-          });
-        }
-
-        const thread: WorkspaceThread = await this.sendPayloadBlocksToChannel({
-          authToken: data.authToken,
-          workspaceChannel: channel,
-          blocks: blocks,
-        });
-
-        workspaceMessageResponse.threads.push(thread);
-
-        logger.debug(`Message sent to channel ID ${channel.id} successfully.`);
-      } catch (e) {
-        logger.error(`Error sending message to channel ID ${channel.id}:`);
-        logger.error(e);
-      }
-    }
+    logger.debug(
+      "Message sent to Teams channel via incoming webhook successfully:",
+    );
+    logger.debug(apiResult);
 
-    logger.debug("Message sent successfully.");
-    logger.debug(workspaceMessageResponse);
+    return apiResult;
+  }
 
-    return workspaceMessageResponse;
+  public static isValidMicrosoftTeamsIncomingWebhookUrl(
+    incomingWebhookUrl: URL,
+  ): boolean {
+    // Check if the URL contains outlook.office.com or office.com webhook pattern
+    const urlString: string = incomingWebhookUrl.toString();
+    return (
+      urlString.includes("outlook.office.com") ||
+      urlString.includes("office.com")
+    );
   }
 }

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

@@ -75,6 +75,7 @@ let StatusPage = class StatusPage extends BaseModel {
         this.allowSubscribersToChooseEventTypes = undefined;
         this.enableSmsSubscribers = undefined;
         this.enableSlackSubscribers = undefined;
+        this.enableMicrosoftTeamsSubscribers = undefined;
         this.copyrightText = undefined;
         this.customFields = undefined;
         this.requireSsoForLogin = undefined;
@@ -1198,6 +1199,45 @@ __decorate([
     }),
     __metadata("design:type", Boolean)
 ], StatusPage.prototype, "enableSlackSubscribers", void 0);
+__decorate([
+    ColumnAccessControl({
+        create: [
+            Permission.ProjectOwner,
+            Permission.ProjectAdmin,
+            Permission.ProjectMember,
+            Permission.CreateProjectStatusPage,
+        ],
+        read: [
+            Permission.ProjectOwner,
+            Permission.ProjectAdmin,
+            Permission.ProjectMember,
+            Permission.ReadProjectStatusPage,
+        ],
+        update: [
+            Permission.ProjectOwner,
+            Permission.ProjectAdmin,
+            Permission.ProjectMember,
+            Permission.EditProjectStatusPage,
+        ],
+    }),
+    TableColumn({
+        isDefaultValueColumn: true,
+        type: TableColumnType.Boolean,
+        title: "Enable Microsoft Teams Subscribers",
+        description: "Can Microsoft Teams subscribers subscribe to this Status Page?",
+        defaultValue: false,
+    }),
+    Column({
+        type: ColumnType.Boolean,
+        default: false,
+    }),
+    ColumnBillingAccessControl({
+        read: PlanType.Free,
+        update: PlanType.Scale,
+        create: PlanType.Free,
+    }),
+    __metadata("design:type", Boolean)
+], StatusPage.prototype, "enableMicrosoftTeamsSubscribers", void 0);
 __decorate([
     ColumnAccessControl({
         create: [