@oneuptime/common 9.2.12 → 9.2.14

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

@@ -29,6 +29,8 @@ import CaptureSpan from "../../Telemetry/CaptureSpan";
 import BadDataException from "../../../../Types/Exception/BadDataException";
 import ObjectID from "../../../../Types/ObjectID";
 import WorkspaceProjectAuthTokenService from "../../../Services/WorkspaceProjectAuthTokenService";
+import WorkspaceUserAuthTokenService from "../../../Services/WorkspaceUserAuthTokenService";
+import WorkspaceUserAuthToken from "../../../../Models/DatabaseModels/WorkspaceUserAuthToken";
 import WorkspaceProjectAuthToken, {
   MicrosoftTeamsMiscData,
   MicrosoftTeamsTeam,
@@ -2815,6 +2817,9 @@ All monitoring checks are passing normally.`;
   @CaptureSpan()
   public static async refreshTeams(data: {
     projectId: ObjectID;
+    // optional: prefer a user-scoped token when provided
+    userId?: ObjectID;
+    userAccessToken?: string;
   }): Promise<Record<string, { id: string; name: string }>> {
     logger.debug("=== refreshTeams called ===");
 
@@ -2848,75 +2853,111 @@ All monitoring checks are passing normally.`;
         );
       }
 
-      // Get a valid app access token
-      const accessToken: string | null = await this.refreshAccessToken({
-        projectId: data.projectId,
-        miscData: projectAuth.miscData as MicrosoftTeamsMiscData,
-        tenantId,
-      });
+      // Try using user scoped token first when available
+      let allTeams: Array<JSONObject> = [];
+      let usedAccessToken: string | null = null;
 
-      if (!accessToken) {
-        throw new BadDataException(
-          "Could not obtain valid access token for Microsoft Teams",
-        );
-      }
-
-      /*
-       * Fetch all teams from Microsoft Graph API using app permissions
-       * Handle pagination to get all teams
-       */
-      const allTeams: Array<JSONObject> = [];
-      let nextLink: string | null = "https://graph.microsoft.com/v1.0/teams";
-      let pageCount: number = 0;
-      const MAX_PAGES: number = MICROSOFT_TEAMS_MAX_PAGES; // Prevent infinite loop
-
-      while (nextLink) {
-        pageCount++;
-        if (pageCount > MAX_PAGES) {
-          logger.error(
-            `Maximum page limit (${MAX_PAGES}) reached while paginating teams. Breaking out to prevent infinite loop.`,
+      try {
+        // If caller provided a userAccessToken directly, use it
+        if (data.userAccessToken) {
+          logger.debug(
+            "Using provided user access token to fetch joined teams",
           );
-          break;
+          usedAccessToken = data.userAccessToken;
+          const userTeams: Record<string, { id: string; name: string }> =
+            await this.getUserJoinedTeams(usedAccessToken);
+          allTeams = Object.values(userTeams) as any;
+        } else if (data.userId) {
+          // Try to fetch stored user auth for this project + user
+          logger.debug("Looking up stored user auth token for provided userId");
+          const userAuth: WorkspaceUserAuthToken | null =
+            await WorkspaceUserAuthTokenService.getUserAuth({
+              projectId: data.projectId,
+              userId: data.userId,
+              workspaceType: WorkspaceType.MicrosoftTeams,
+            });
+
+          if (userAuth && userAuth.authToken) {
+            usedAccessToken = userAuth.authToken;
+            logger.debug(
+              "Found user auth token; using it to fetch joined teams",
+            );
+            const userTeams: Record<string, { id: string; name: string }> =
+              await this.getUserJoinedTeams(usedAccessToken);
+            allTeams = Object.values(userTeams) as any;
+          }
         }
-        logger.debug(`Fetching teams page ${pageCount}: ${nextLink}`);
+      } catch (err) {
+        logger.warn(
+          "Failed to fetch teams using user-scoped token, falling back to app token:",
+        );
+        logger.warn(err);
+        allTeams = [];
+      }
 
-        const teamsResponse: HTTPErrorResponse | HTTPResponse<JSONObject> =
-          await API.get<JSONObject>({
-            url: URL.fromString(nextLink),
-            headers: {
-              Authorization: `Bearer ${accessToken}`,
-            },
-          });
+      // If we couldn't obtain teams via user token, fall back to app-scoped token + existing behavior
+      if (!allTeams || allTeams.length === 0) {
+        // Get a valid app access token
+        const accessToken: string | null = await this.refreshAccessToken({
+          projectId: data.projectId,
+          miscData: projectAuth.miscData as MicrosoftTeamsMiscData,
+          tenantId,
+        });
 
-        if (teamsResponse instanceof HTTPErrorResponse) {
-          logger.error("Error fetching teams from Microsoft Teams:");
-          logger.error(teamsResponse);
+        if (!accessToken) {
           throw new BadDataException(
-            "Failed to fetch teams from Microsoft Teams",
+            "Could not obtain valid access token for Microsoft Teams",
           );
         }
 
-        const teams: Array<JSONObject> =
-          (teamsResponse.data as any)["value"] || [];
-        allTeams.push(...teams);
+        /*
+         * Fetch all teams from Microsoft Graph API using app permissions
+         * Handle pagination to get all teams
+         */
+        allTeams = [];
+        let nextLink: string | null = "https://graph.microsoft.com/v1.0/teams";
+        let pageCount: number = 0;
+        const MAX_PAGES: number = MICROSOFT_TEAMS_MAX_PAGES; // Prevent infinite loop
+
+        while (nextLink) {
+          pageCount++;
+          if (pageCount > MAX_PAGES) {
+            logger.error(
+              `Maximum page limit (${MAX_PAGES}) reached while paginating teams. Breaking out to prevent infinite loop.`,
+            );
+            break;
+          }
+          logger.debug(`Fetching teams page ${pageCount}: ${nextLink}`);
+
+          const teamsResponse: HTTPErrorResponse | HTTPResponse<JSONObject> =
+            await API.get<JSONObject>({
+              url: URL.fromString(nextLink),
+              headers: {
+                Authorization: `Bearer ${accessToken}`,
+              },
+            });
+
+          if (teamsResponse instanceof HTTPErrorResponse) {
+            logger.error("Error fetching teams from Microsoft Teams:");
+            logger.error(teamsResponse);
+            throw new BadDataException(
+              "Failed to fetch teams from Microsoft Teams",
+            );
+          }
 
-        // Check for next page
-        nextLink = (teamsResponse.data as any)["@odata.nextLink"] || null;
+          const teams: Array<JSONObject> =
+            (teamsResponse.data as any)["value"] || [];
+          allTeams.push(...teams);
 
-        logger.debug(
-          `Page ${pageCount}: Fetched ${teams.length} teams. Total so far: ${allTeams.length}`,
-        );
-      }
+          // Check for next page
+          nextLink = (teamsResponse.data as any)["@odata.nextLink"] || null;
 
-      if (allTeams.length === 0) {
-        logger.debug("No teams found in organization");
-        return {};
+          logger.debug(
+            `Page ${pageCount}: Fetched ${teams.length} teams. Total so far: ${allTeams.length}`,
+          );
+        }
       }
 
-      logger.debug(
-        `Completed fetching all teams. Total pages: ${pageCount}, Total teams: ${allTeams.length}`,
-      );
-
       // Process teams
       const availableTeams: Record<string, { id: string; name: string }> =
         allTeams.reduce(

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

@@ -12,6 +12,9 @@ enum SlackActionType {
   NewIncident = "/incident", // new incident slash command
   SubmitNewIncident = "SubmitNewIncident",
 
+  // Emoji Reaction Actions
+  EmojiReactionAdded = "EmojiReactionAdded",
+
   // Alert Actions just like Incident Actions
   AcknowledgeAlert = "AcknowledgeAlert",
   ResolveAlert = "ResolveAlert",
@@ -41,4 +44,17 @@ enum SlackActionType {
   ViewOnCallPolicy = "ViewOnCallPolicy",
 }
 
+// Emoji names that trigger saving a message as a Private Note (Internal Note)
+export const PrivateNoteEmojis: string[] = ["pushpin", "round_pushpin", "pin"];
+
+// Emoji names that trigger saving a message as a Public Note
+export const PublicNoteEmojis: string[] = [
+  "mega",
+  "loudspeaker",
+  "megaphone",
+  "announcement",
+  "speaking_head_in_silhouette",
+  "speaking_head",
+];
+
 export default SlackActionType;

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

@@ -3,7 +3,7 @@ import ObjectID from "../../../../../Types/ObjectID";
 import AlertService from "../../../../Services/AlertService";
 import { ExpressRequest, ExpressResponse } from "../../../Express";
 import SlackUtil from "../Slack";
-import SlackActionType from "./ActionTypes";
+import SlackActionType, { PrivateNoteEmojis } from "./ActionTypes";
 import { SlackAction, SlackRequest } from "./Auth";
 import Response from "../../../Response";
 import {
@@ -24,7 +24,12 @@ import logger from "../../../Logger";
 import AccessTokenService from "../../../../Services/AccessTokenService";
 import CaptureSpan from "../../../Telemetry/CaptureSpan";
 import WorkspaceNotificationLogService from "../../../../Services/WorkspaceNotificationLogService";
+import WorkspaceUserAuthTokenService from "../../../../Services/WorkspaceUserAuthTokenService";
 import WorkspaceType from "../../../../../Types/Workspace/WorkspaceType";
+import WorkspaceProjectAuthTokenService from "../../../../Services/WorkspaceProjectAuthTokenService";
+import WorkspaceNotificationLog from "../../../../../Models/DatabaseModels/WorkspaceNotificationLog";
+import WorkspaceProjectAuthToken from "../../../../../Models/DatabaseModels/WorkspaceProjectAuthToken";
+import WorkspaceUserAuthToken from "../../../../../Models/DatabaseModels/WorkspaceUserAuthToken";
 
 export default class SlackAlertActions {
   @CaptureSpan()
@@ -773,4 +778,182 @@ export default class SlackAlertActions {
       new BadDataException("Invalid Action Type"),
     );
   }
+
+  @CaptureSpan()
+  public static async handleEmojiReaction(data: {
+    teamId: string;
+    reaction: string;
+    userId: string;
+    channelId: string;
+    messageTs: string;
+  }): Promise<void> {
+    logger.debug("Handling emoji reaction for Alert with data:");
+    logger.debug(data);
+
+    const { teamId, reaction, userId, channelId, messageTs } = data;
+
+    // Alerts only support private notes, so only pushpin emojis work
+    const isPrivateNoteEmoji: boolean = PrivateNoteEmojis.includes(reaction);
+
+    if (!isPrivateNoteEmoji) {
+      logger.debug(
+        `Emoji "${reaction}" is not a supported private note emoji for alerts. Ignoring.`,
+      );
+      return;
+    }
+
+    // Get the project auth token using the team ID
+    const projectAuth: WorkspaceProjectAuthToken | null =
+      await WorkspaceProjectAuthTokenService.findOneBy({
+        query: {
+          workspaceProjectId: teamId,
+        },
+        select: {
+          projectId: true,
+          authToken: true,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+    if (!projectAuth || !projectAuth.projectId || !projectAuth.authToken) {
+      logger.debug(
+        "No project auth found for team ID. Ignoring emoji reaction.",
+      );
+      return;
+    }
+
+    const projectId: ObjectID = projectAuth.projectId;
+    const authToken: string = projectAuth.authToken;
+
+    // Find the alert linked to this channel
+    const workspaceLog: WorkspaceNotificationLog | null =
+      await WorkspaceNotificationLogService.findOneBy({
+        query: {
+          channelId: channelId,
+          workspaceType: WorkspaceType.Slack,
+          projectId: projectId,
+        },
+        select: {
+          alertId: true,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+    if (!workspaceLog || !workspaceLog.alertId) {
+      logger.debug(
+        "No alert found linked to this channel. Ignoring emoji reaction.",
+      );
+      return;
+    }
+
+    const alertId: ObjectID = workspaceLog.alertId;
+
+    // Get the alert number for the confirmation message
+    const alertNumber: number | null = await AlertService.getAlertNumber({
+      alertId: alertId,
+    });
+
+    // Get the user ID in OneUptime based on Slack user ID
+    const userAuth: WorkspaceUserAuthToken | null =
+      await WorkspaceUserAuthTokenService.findOneBy({
+        query: {
+          workspaceUserId: userId,
+          workspaceType: WorkspaceType.Slack,
+          projectId: projectId,
+        },
+        select: {
+          userId: true,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+    if (!userAuth || !userAuth.userId) {
+      logger.debug(
+        "No OneUptime user found for Slack user. Ignoring emoji reaction.",
+      );
+      return;
+    }
+
+    const oneUptimeUserId: ObjectID = userAuth.userId;
+
+    // Fetch the message text using the timestamp
+    let messageText: string | null = null;
+    try {
+      messageText = await SlackUtil.getMessageByTimestamp({
+        authToken: authToken,
+        channelId: channelId,
+        messageTs: messageTs,
+      });
+    } catch (err) {
+      logger.error("Error fetching message text:");
+      logger.error(err);
+      return;
+    }
+
+    if (!messageText) {
+      logger.debug("No message text found. Ignoring emoji reaction.");
+      return;
+    }
+
+    // Create a unique identifier for this Slack message to prevent duplicate notes
+    const postedFromSlackMessageId: string = `${channelId}:${messageTs}`;
+
+    // Check if a note from this Slack message already exists
+    const hasExistingNote: boolean =
+      await AlertInternalNoteService.hasNoteFromSlackMessage({
+        alertId: alertId,
+        postedFromSlackMessageId: postedFromSlackMessageId,
+      });
+
+    if (hasExistingNote) {
+      logger.debug(
+        "Private note from this Slack message already exists. Skipping duplicate.",
+      );
+      return;
+    }
+
+    // Save as private note (Alerts only support private notes)
+    try {
+      await AlertInternalNoteService.addNote({
+        alertId: alertId,
+        note: messageText,
+        projectId: projectId,
+        userId: oneUptimeUserId,
+        postedFromSlackMessageId: postedFromSlackMessageId,
+      });
+      logger.debug("Private note added to alert successfully.");
+    } catch (err) {
+      logger.error("Error saving note:");
+      logger.error(err);
+      return;
+    }
+
+    // Send confirmation message as a reply to the original message thread
+    try {
+      const alertLink: string = (
+        await AlertService.getAlertLinkInDashboard(projectId, alertId)
+      ).toString();
+
+      const confirmationMessage: string = `✅ Message saved as *private note* to <${alertLink}|Alert #${alertNumber}>.`;
+
+      await SlackUtil.sendMessageToThread({
+        authToken: authToken,
+        channelId: channelId,
+        threadTs: messageTs,
+        text: confirmationMessage,
+      });
+
+      logger.debug("Confirmation message sent successfully.");
+    } catch (err) {
+      logger.error("Error sending confirmation message:");
+      logger.error(err);
+      // Don't throw - note was saved successfully, confirmation is best effort
+    }
+  }
 }

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

@@ -3,7 +3,10 @@ import ObjectID from "../../../../../Types/ObjectID";
 import IncidentService from "../../../../Services/IncidentService";
 import { ExpressRequest, ExpressResponse } from "../../../Express";
 import SlackUtil from "../Slack";
-import SlackActionType from "./ActionTypes";
+import SlackActionType, {
+  PrivateNoteEmojis,
+  PublicNoteEmojis,
+} from "./ActionTypes";
 import { SlackAction, SlackRequest } from "./Auth";
 import Response from "../../../Response";
 import {
@@ -38,6 +41,11 @@ import LabelService from "../../../../Services/LabelService";
 import Incident from "../../../../../Models/DatabaseModels/Incident";
 import AccessTokenService from "../../../../Services/AccessTokenService";
 import CaptureSpan from "../../../Telemetry/CaptureSpan";
+import WorkspaceProjectAuthTokenService from "../../../../Services/WorkspaceProjectAuthTokenService";
+import WorkspaceUserAuthTokenService from "../../../../Services/WorkspaceUserAuthTokenService";
+import WorkspaceNotificationLog from "../../../../../Models/DatabaseModels/WorkspaceNotificationLog";
+import WorkspaceProjectAuthToken from "../../../../../Models/DatabaseModels/WorkspaceProjectAuthToken";
+import WorkspaceUserAuthToken from "../../../../../Models/DatabaseModels/WorkspaceUserAuthToken";
 
 export default class SlackIncidentActions {
   @CaptureSpan()
@@ -1285,4 +1293,219 @@ export default class SlackIncidentActions {
       new BadDataException("Invalid Action Type"),
     );
   }
+
+  @CaptureSpan()
+  public static async handleEmojiReaction(data: {
+    teamId: string;
+    reaction: string;
+    userId: string;
+    channelId: string;
+    messageTs: string;
+  }): Promise<void> {
+    logger.debug("Handling emoji reaction with data:");
+    logger.debug(data);
+
+    const { teamId, reaction, userId, channelId, messageTs } = data;
+
+    // Check if the emoji is a supported private or public note emoji
+    const isPrivateNoteEmoji: boolean = PrivateNoteEmojis.includes(reaction);
+    const isPublicNoteEmoji: boolean = PublicNoteEmojis.includes(reaction);
+
+    if (!isPrivateNoteEmoji && !isPublicNoteEmoji) {
+      logger.debug(
+        `Emoji "${reaction}" is not a supported note emoji. Ignoring.`,
+      );
+      return;
+    }
+
+    // Get the project auth token using the team ID
+    const projectAuth: WorkspaceProjectAuthToken | null =
+      await WorkspaceProjectAuthTokenService.findOneBy({
+        query: {
+          workspaceProjectId: teamId,
+        },
+        select: {
+          projectId: true,
+          authToken: true,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+    if (!projectAuth || !projectAuth.projectId || !projectAuth.authToken) {
+      logger.debug(
+        "No project auth found for team ID. Ignoring emoji reaction.",
+      );
+      return;
+    }
+
+    const projectId: ObjectID = projectAuth.projectId;
+    const authToken: string = projectAuth.authToken;
+
+    // Find the incident linked to this channel
+    const workspaceLog: WorkspaceNotificationLog | null =
+      await WorkspaceNotificationLogService.findOneBy({
+        query: {
+          channelId: channelId,
+          workspaceType: WorkspaceType.Slack,
+          projectId: projectId,
+        },
+        select: {
+          incidentId: true,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+    if (!workspaceLog || !workspaceLog.incidentId) {
+      logger.debug(
+        "No incident found linked to this channel. Ignoring emoji reaction.",
+      );
+      return;
+    }
+
+    const incidentId: ObjectID = workspaceLog.incidentId;
+
+    // Get the incident number for the confirmation message
+    const incidentNumber: number | null =
+      await IncidentService.getIncidentNumber({
+        incidentId: incidentId,
+      });
+
+    // Get the user ID in OneUptime based on Slack user ID
+    const userAuth: WorkspaceUserAuthToken | null =
+      await WorkspaceUserAuthTokenService.findOneBy({
+        query: {
+          workspaceUserId: userId,
+          workspaceType: WorkspaceType.Slack,
+          projectId: projectId,
+        },
+        select: {
+          userId: true,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+    if (!userAuth || !userAuth.userId) {
+      logger.debug(
+        "No OneUptime user found for Slack user. Ignoring emoji reaction.",
+      );
+      return;
+    }
+
+    const oneUptimeUserId: ObjectID = userAuth.userId;
+
+    // Fetch the message text using the timestamp
+    let messageText: string | null = null;
+    try {
+      messageText = await SlackUtil.getMessageByTimestamp({
+        authToken: authToken,
+        channelId: channelId,
+        messageTs: messageTs,
+      });
+    } catch (err) {
+      logger.error("Error fetching message text:");
+      logger.error(err);
+      return;
+    }
+
+    if (!messageText) {
+      logger.debug("No message text found. Ignoring emoji reaction.");
+      return;
+    }
+
+    // Create a unique identifier for this Slack message to prevent duplicate notes
+    const postedFromSlackMessageId: string = `${channelId}:${messageTs}`;
+
+    // Save the note based on the emoji type
+    let noteType: string;
+    try {
+      if (isPrivateNoteEmoji) {
+        noteType = "private";
+
+        // Check if a note from this Slack message already exists
+        const hasExistingNote: boolean =
+          await IncidentInternalNoteService.hasNoteFromSlackMessage({
+            incidentId: incidentId,
+            postedFromSlackMessageId: postedFromSlackMessageId,
+          });
+
+        if (hasExistingNote) {
+          logger.debug(
+            "Private note from this Slack message already exists. Skipping duplicate.",
+          );
+          return;
+        }
+
+        await IncidentInternalNoteService.addNote({
+          incidentId: incidentId,
+          note: messageText,
+          projectId: projectId,
+          userId: oneUptimeUserId,
+          postedFromSlackMessageId: postedFromSlackMessageId,
+        });
+        logger.debug("Private note added successfully.");
+      } else if (isPublicNoteEmoji) {
+        noteType = "public";
+
+        // Check if a note from this Slack message already exists
+        const hasExistingNote: boolean =
+          await IncidentPublicNoteService.hasNoteFromSlackMessage({
+            incidentId: incidentId,
+            postedFromSlackMessageId: postedFromSlackMessageId,
+          });
+
+        if (hasExistingNote) {
+          logger.debug(
+            "Public note from this Slack message already exists. Skipping duplicate.",
+          );
+          return;
+        }
+
+        await IncidentPublicNoteService.addNote({
+          incidentId: incidentId,
+          note: messageText,
+          projectId: projectId,
+          userId: oneUptimeUserId,
+          postedFromSlackMessageId: postedFromSlackMessageId,
+        });
+        logger.debug("Public note added successfully.");
+      } else {
+        return;
+      }
+    } catch (err) {
+      logger.error("Error saving note:");
+      logger.error(err);
+      return;
+    }
+
+    // Send confirmation message as a reply to the original message thread
+    try {
+      const incidentLink: string = (
+        await IncidentService.getIncidentLinkInDashboard(projectId, incidentId)
+      ).toString();
+
+      const confirmationMessage: string =
+        noteType === "private"
+          ? `✅ Message saved as *private note* to <${incidentLink}|Incident #${incidentNumber}>.`
+          : `✅ Message saved as *public note* to <${incidentLink}|Incident #${incidentNumber}>. This note will be visible on the status page.`;
+
+      await SlackUtil.sendMessageToThread({
+        authToken: authToken,
+        channelId: channelId,
+        threadTs: messageTs,
+        text: confirmationMessage,
+      });
+
+      logger.debug("Confirmation message sent successfully.");
+    } catch (err) {
+      logger.error("Error sending confirmation message:");
+      logger.error(err);
+      // Don't throw - note was saved successfully, confirmation is best effort
+    }
+  }
 }