@oneuptime/common 9.2.12 → 9.2.14

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

@@ -3,7 +3,10 @@ import ObjectID from "../../../../../Types/ObjectID";
 import ScheduledMaintenanceService from "../../../../Services/ScheduledMaintenanceService";
 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 {
@@ -34,7 +37,12 @@ import OneUptimeDate from "../../../../../Types/Date";
 import AccessTokenService from "../../../../Services/AccessTokenService";
 import CaptureSpan from "../../../Telemetry/CaptureSpan";
 import WorkspaceType from "../../../../../Types/Workspace/WorkspaceType";
+import WorkspaceUserAuthTokenService from "../../../../Services/WorkspaceUserAuthTokenService";
 import WorkspaceNotificationLogService from "../../../../Services/WorkspaceNotificationLogService";
+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 SlackScheduledMaintenanceActions {
   @CaptureSpan()
@@ -1110,4 +1118,227 @@ export default class SlackScheduledMaintenanceActions {
       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 Scheduled Maintenance 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 scheduled maintenance linked to this channel
+    const workspaceLog: WorkspaceNotificationLog | null =
+      await WorkspaceNotificationLogService.findOneBy({
+        query: {
+          channelId: channelId,
+          workspaceType: WorkspaceType.Slack,
+          projectId: projectId,
+        },
+        select: {
+          scheduledMaintenanceId: true,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+    if (!workspaceLog || !workspaceLog.scheduledMaintenanceId) {
+      logger.debug(
+        "No scheduled maintenance found linked to this channel. Ignoring emoji reaction.",
+      );
+      return;
+    }
+
+    const scheduledMaintenanceId: ObjectID =
+      workspaceLog.scheduledMaintenanceId;
+
+    // Get the scheduled maintenance number for the confirmation message
+    const scheduledMaintenanceNumber: number | null =
+      await ScheduledMaintenanceService.getScheduledMaintenanceNumber({
+        scheduledMaintenanceId: scheduledMaintenanceId,
+      });
+
+    // 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 ScheduledMaintenanceInternalNoteService.hasNoteFromSlackMessage(
+            {
+              scheduledMaintenanceId: scheduledMaintenanceId,
+              postedFromSlackMessageId: postedFromSlackMessageId,
+            },
+          );
+
+        if (hasExistingNote) {
+          logger.debug(
+            "Private note from this Slack message already exists. Skipping duplicate.",
+          );
+          return;
+        }
+
+        await ScheduledMaintenanceInternalNoteService.addNote({
+          scheduledMaintenanceId: scheduledMaintenanceId,
+          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 ScheduledMaintenancePublicNoteService.hasNoteFromSlackMessage({
+            scheduledMaintenanceId: scheduledMaintenanceId,
+            postedFromSlackMessageId: postedFromSlackMessageId,
+          });
+
+        if (hasExistingNote) {
+          logger.debug(
+            "Public note from this Slack message already exists. Skipping duplicate.",
+          );
+          return;
+        }
+
+        await ScheduledMaintenancePublicNoteService.addNote({
+          scheduledMaintenanceId: scheduledMaintenanceId,
+          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 scheduledMaintenanceLink: string = (
+        await ScheduledMaintenanceService.getScheduledMaintenanceLinkInDashboard(
+          projectId,
+          scheduledMaintenanceId,
+        )
+      ).toString();
+
+      const confirmationMessage: string =
+        noteType === "private"
+          ? `✅ Message saved as *private note* to <${scheduledMaintenanceLink}|Scheduled Maintenance #${scheduledMaintenanceNumber}>.`
+          : `✅ Message saved as *public note* to <${scheduledMaintenanceLink}|Scheduled Maintenance #${scheduledMaintenanceNumber}>. 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
+    }
+  }
 }

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

@@ -1156,6 +1156,119 @@ export default class SlackUtil extends WorkspaceBase {
     };
   }
 
+  @CaptureSpan()
+  public static async sendMessageToThread(data: {
+    authToken: string;
+    channelId: string;
+    threadTs: string;
+    text: string;
+  }): Promise<void> {
+    logger.debug("Sending message to thread with data:");
+    logger.debug(data);
+
+    const response: HTTPErrorResponse | HTTPResponse<JSONObject> =
+      await API.post({
+        url: URL.fromString("https://slack.com/api/chat.postMessage"),
+        data: {
+          channel: data.channelId,
+          thread_ts: data.threadTs,
+          text: data.text,
+        },
+        headers: {
+          Authorization: `Bearer ${data.authToken}`,
+          ["Content-Type"]: "application/json",
+        },
+        options: {
+          retries: 3,
+          exponentialBackoff: true,
+        },
+      });
+
+    logger.debug("Response from Slack API for sending thread message:");
+    logger.debug(response);
+
+    if (response instanceof HTTPErrorResponse) {
+      logger.error("Error response from Slack API:");
+      logger.error(response);
+      throw response;
+    }
+
+    if ((response.jsonData as JSONObject)?.["ok"] !== true) {
+      logger.error("Invalid response from Slack API:");
+      logger.error(response.jsonData);
+      const messageFromSlack: string = (response.jsonData as JSONObject)?.[
+        "error"
+      ] as string;
+      throw new BadRequestException("Error from Slack " + messageFromSlack);
+    }
+
+    logger.debug("Thread message sent successfully.");
+  }
+
+  @CaptureSpan()
+  public static async getMessageByTimestamp(data: {
+    authToken: string;
+    channelId: string;
+    messageTs: string;
+  }): Promise<string | null> {
+    logger.debug("Getting message by timestamp with data:");
+    logger.debug(data);
+
+    const response: HTTPErrorResponse | HTTPResponse<JSONObject> =
+      await API.post({
+        url: URL.fromString("https://slack.com/api/conversations.history"),
+        data: {
+          channel: data.channelId,
+          latest: data.messageTs,
+          oldest: data.messageTs,
+          inclusive: true,
+          limit: 1,
+        },
+        headers: {
+          Authorization: `Bearer ${data.authToken}`,
+          ["Content-Type"]: "application/x-www-form-urlencoded",
+        },
+        options: {
+          retries: 3,
+          exponentialBackoff: true,
+        },
+      });
+
+    logger.debug("Response from Slack API for getting message:");
+    logger.debug(response);
+
+    if (response instanceof HTTPErrorResponse) {
+      logger.error("Error response from Slack API:");
+      logger.error(response);
+      throw response;
+    }
+
+    if ((response.jsonData as JSONObject)?.["ok"] !== true) {
+      logger.error("Invalid response from Slack API:");
+      logger.error(response.jsonData);
+      const messageFromSlack: string = (response.jsonData as JSONObject)?.[
+        "error"
+      ] as string;
+      throw new BadRequestException("Error from Slack " + messageFromSlack);
+    }
+
+    const messages: Array<JSONObject> = (response.jsonData as JSONObject)?.[
+      "messages"
+    ] as Array<JSONObject>;
+
+    if (!messages || messages.length === 0) {
+      logger.debug("No messages found for timestamp.");
+      return null;
+    }
+
+    const messageText: string | undefined = messages[0]?.["text"] as string;
+
+    logger.debug("Message text retrieved:");
+    logger.debug(messageText);
+
+    return messageText || null;
+  }
+
   @CaptureSpan()
   public static override getButtonsBlock(data: {
     payloadButtonsBlock: WorkspacePayloadButtons;

package/Server/Utils/Workspace/Slack/app-manifest.json

@@ -5,6 +5,7 @@
         "background_color": "#000000",
         "long_description": "OneUptime is a comprehensive solution for monitoring and managing your online services. Whether you need to check the availability of your website, dashboard, API, or any other online resource, OneUptime can alert your team when downtime happens and keep your customers informed with a status page. OneUptime also helps you handle incidents, set up on-call rotations, run tests, secure your services, analyze logs, track performance, and debug errors."
     },
+
     "features": {
         "app_home": {
             "home_tab_enabled": false,
@@ -66,10 +67,14 @@
                 "users:read",
                 "groups:read",
                 "groups:write",
+                "groups:history",
                 "im:read",
                 "im:write",
+                "im:history",
                 "mpim:read",
-                "mpim:write"
+                "mpim:write",
+                "mpim:history",
+                "reactions:read"
             ]
         }
     },
@@ -81,6 +86,12 @@
         },
         "org_deploy_enabled": true,
         "socket_mode_enabled": false,
-        "token_rotation_enabled": false
+        "token_rotation_enabled": false,
+        "event_subscriptions": {
+            "request_url": "{{SERVER_URL}}/api/slack/events",
+            "bot_events": [
+                "reaction_added"
+            ]
+        }
     }
 }

package/Tests/Server/Utils/StatusPageResource.test.ts

@@ -0,0 +1,161 @@
+import StatusPageResourceUtil from "../../../Server/Utils/StatusPageResource";
+import StatusPageResource from "../../../Models/DatabaseModels/StatusPageResource";
+import ObjectID from "../../../Types/ObjectID";
+
+describe("StatusPageResourceUtil", () => {
+  describe("getResourcesGroupedByGroupName", () => {
+    it("should return empty string for empty resources array", () => {
+      const result: string =
+        StatusPageResourceUtil.getResourcesGroupedByGroupName([]);
+      expect(result).toBe("");
+    });
+
+    it("should return custom default value for empty resources array", () => {
+      const result: string =
+        StatusPageResourceUtil.getResourcesGroupedByGroupName(
+          [],
+          "No resources",
+        );
+      expect(result).toBe("No resources");
+    });
+
+    it("should return simple comma-separated list when no resources have groups", () => {
+      const resources: Array<StatusPageResource> = [
+        createResource("API"),
+        createResource("Website"),
+        createResource("Database"),
+      ];
+
+      const result: string =
+        StatusPageResourceUtil.getResourcesGroupedByGroupName(resources);
+      expect(result).toBe("API, Website, Database");
+    });
+
+    it("should group resources by their resource group name", () => {
+      const resources: Array<StatusPageResource> = [
+        createResourceWithGroup("Infrastructure", "EU"),
+        createResourceWithGroup("Website", "EU"),
+        createResourceWithGroup("Infrastructure", "UK"),
+        createResourceWithGroup("API", "UK"),
+      ];
+
+      const result: string =
+        StatusPageResourceUtil.getResourcesGroupedByGroupName(resources);
+      /*
+       * Groups should be formatted as "GroupName: Resource1, Resource2"
+       * Multiple groups separated by <br/> for HTML rendering
+       */
+      expect(result).toContain("EU: Infrastructure, Website");
+      expect(result).toContain("UK: Infrastructure, API");
+      expect(result).toContain("<br/>");
+    });
+
+    it("should handle mixed grouped and ungrouped resources", () => {
+      const resources: Array<StatusPageResource> = [
+        createResourceWithGroup("Infrastructure", "EU"),
+        createResource("Global API"),
+        createResourceWithGroup("Website", "UK"),
+      ];
+
+      const result: string =
+        StatusPageResourceUtil.getResourcesGroupedByGroupName(resources);
+      expect(result).toContain("EU: Infrastructure");
+      expect(result).toContain("UK: Website");
+      // Ungrouped resources should appear on their own line without "Other" label
+      expect(result).toContain("Global API");
+      expect(result).not.toContain("Other:");
+    });
+
+    it("should handle single grouped resource", () => {
+      const resources: Array<StatusPageResource> = [
+        createResourceWithGroup("Infrastructure", "EU"),
+      ];
+
+      const result: string =
+        StatusPageResourceUtil.getResourcesGroupedByGroupName(resources);
+      expect(result).toBe("EU: Infrastructure");
+    });
+
+    it("should handle single ungrouped resource", () => {
+      const resources: Array<StatusPageResource> = [createResource("API")];
+
+      const result: string =
+        StatusPageResourceUtil.getResourcesGroupedByGroupName(resources);
+      expect(result).toBe("API");
+    });
+
+    it("should skip resources without displayName", () => {
+      const resources: Array<StatusPageResource> = [
+        createResource("API"),
+        createResourceWithoutDisplayName(),
+        createResource("Website"),
+      ];
+
+      const result: string =
+        StatusPageResourceUtil.getResourcesGroupedByGroupName(resources);
+      expect(result).toBe("API, Website");
+    });
+
+    it("should handle null resources array", () => {
+      const result: string =
+        StatusPageResourceUtil.getResourcesGroupedByGroupName(
+          null as unknown as Array<StatusPageResource>,
+        );
+      expect(result).toBe("");
+    });
+
+    it("should return empty string as default when specified", () => {
+      const result: string =
+        StatusPageResourceUtil.getResourcesGroupedByGroupName([], "");
+      expect(result).toBe("");
+    });
+
+    it("should handle multiple resources in same group", () => {
+      const resources: Array<StatusPageResource> = [
+        createResourceWithGroup("Infrastructure", "EU"),
+        createResourceWithGroup("Website", "EU"),
+        createResourceWithGroup("API", "EU"),
+      ];
+
+      const result: string =
+        StatusPageResourceUtil.getResourcesGroupedByGroupName(resources);
+      expect(result).toBe("EU: Infrastructure, Website, API");
+    });
+  });
+});
+
+/**
+ * Helper function to create a StatusPageResource without a group
+ */
+function createResource(displayName: string): StatusPageResource {
+  const resource: StatusPageResource = new StatusPageResource();
+  resource._id = ObjectID.generate().toString();
+  resource.displayName = displayName;
+  return resource;
+}
+
+/**
+ * Helper function to create a StatusPageResource with a group
+ */
+function createResourceWithGroup(
+  displayName: string,
+  groupName: string,
+): StatusPageResource {
+  const resource: StatusPageResource = new StatusPageResource();
+  resource._id = ObjectID.generate().toString();
+  resource.displayName = displayName;
+  resource.statusPageGroupId = ObjectID.generate();
+  resource.statusPageGroup = {
+    name: groupName,
+  } as any;
+  return resource;
+}
+
+/**
+ * Helper function to create a StatusPageResource without a displayName
+ */
+function createResourceWithoutDisplayName(): StatusPageResource {
+  const resource: StatusPageResource = new StatusPageResource();
+  resource._id = ObjectID.generate().toString();
+  return resource;
+}

package/Types/Icon/IconProp.ts

@@ -140,6 +140,7 @@ enum IconProp {
   SquareStack3D = "SquareStack3D",
   ExclaimationCircle = "ExclaimationCircle",
   WhatsApp = "WhatsApp",
+  Brain = "Brain",
 }
 
 export default IconProp;

package/Types/LLM/Index.ts

@@ -0,0 +1,4 @@
+import LlmType from "./LlmType";
+
+export default LlmType;
+export { LlmType };

package/Types/LLM/LlmType.ts

@@ -0,0 +1,7 @@
+enum LlmType {
+  OpenAI = "OpenAI",
+  Anthropic = "Anthropic",
+  Ollama = "Ollama",
+}
+
+export default LlmType;