@oneuptime/common 7.0.3717 → 7.0.3786

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

@@ -19,29 +19,36 @@
             {
                 "name": "Create Scheduled Event",
                 "type": "global",
-                "callback_id": "create-scheduled-maintenance",
+                "callback_id": "/maintenance",
                 "description": "Create a new scheduled event in OneUptime"
             },
             {
                 "name": "Create New Incident",
                 "type": "global",
-                "callback_id": "create-incident",
+                "callback_id": "/incident",
                 "description": "Creates a new incident in OneUptime"
             }
         ],
         "slash_commands": [
             {
-                "command": "/oneuptime",
-                "url": "https://local.genosyn.com/api/slack/command",
-                "description": "OneUptime command",
-                "usage_hint": "incident, scheduled event.",
+                "command": "/incident",
+                "url": "{{SERVER_URL}}/api/slack/interactive",
+                "description": "Create a new Incident in OneUptime",
+                "usage_hint": "/incident [incident title]",
+                "should_escape": false
+            },
+            {
+                "command": "/maintenance",
+                "url": "{{SERVER_URL}}/api/slack/interactive",
+                "description": "Create a new Scheduled Maintenance in OneUptime",
+                "usage_hint": "/maintenance [maintenance title]",
                 "should_escape": false
             }
         ]
     },
     "oauth_config": {
         "redirect_urls": [
-            "https://local.genosyn.com/api/slack/auth"
+            "{{SERVER_URL}}/api/slack/auth"
         ],
         "scopes": {
             "user": [
@@ -55,15 +62,16 @@
                 "channels:read",
                 "channels:write.invites",
                 "channels:write.topic",
-                "chat:write"
+                "chat:write",
+                "users:read"
             ]
         }
     },
     "settings": {
         "interactivity": {
             "is_enabled": true,
-            "request_url": "https://local.genosyn.com/api/slack/interactive",
-            "message_menu_options_url": "https://local.genosyn.com/api/slack/options-load"
+            "request_url": "{{SERVER_URL}}/api/slack/interactive",
+            "message_menu_options_url": "{{SERVER_URL}}/api/slack/options-load"
         },
         "org_deploy_enabled": true,
         "socket_mode_enabled": false,

package/Server/Utils/Workspace/Workspace.ts

@@ -1,10 +1,98 @@
 import WorkspaceType from "../../../Types/Workspace/WorkspaceType";
-import WorkspaceBase from "./WorkspaceBase";
+import WorkspaceBase, { WorkspaceSendMessageResponse } from "./WorkspaceBase";
 import SlackWorkspace from "./Slack/Slack";
 import MicrosoftTeamsWorkspace from "./MicrosoftTeams/MicrosoftTeams";
 import BadDataException from "../../../Types/Exception/BadDataException";
+import ObjectID from "../../../Types/ObjectID";
+import WorkspaceMessagePayload, {
+  WorkspacePayloadMarkdown,
+} from "../../../Types/Workspace/WorkspaceMessagePayload";
+import logger from "../Logger";
+import WorkspaceProjectAuthTokenService from "../../Services/WorkspaceProjectAuthTokenService";
+import WorkspaceProjectAuthToken, {
+  SlackMiscData,
+} from "../../../Models/DatabaseModels/WorkspaceProjectAuthToken";
+import { MessageBlocksByWorkspaceType } from "../../Services/WorkspaceNotificationRuleService";
+import WorkspaceUserAuthToken from "../../../Models/DatabaseModels/WorkspaceUserAuthToken";
+import WorkspaceUserAuthTokenService from "../../Services/WorkspaceUserAuthTokenService";
+import UserService from "../../Services/UserService";
 
 export default class WorkspaceUtil {
+  public static async getMessageBlocksByMarkdown(data: {
+    projectId: ObjectID;
+    // this is oneuptime user id.
+    userId: ObjectID | undefined;
+    markdown: string;
+  }): Promise<Array<MessageBlocksByWorkspaceType>> {
+    const workspaceTypes: Array<WorkspaceType> = this.getAllWorkspaceTypes();
+
+    const messageBlocksByWorkspaceType: Array<MessageBlocksByWorkspaceType> =
+      [];
+
+    for (const workspaceType of workspaceTypes) {
+      let userStringToAppend: string = "";
+
+      if (data.userId) {
+        const workspaceUserToken: WorkspaceUserAuthToken | null =
+          await WorkspaceUserAuthTokenService.getUserAuth({
+            userId: data.userId,
+            workspaceType: workspaceType,
+            projectId: data.projectId,
+          });
+
+        if (workspaceUserToken && workspaceUserToken.workspaceUserId) {
+          const projectAuthToken: WorkspaceProjectAuthToken | null =
+            await WorkspaceProjectAuthTokenService.getProjectAuth({
+              projectId: data.projectId,
+              workspaceType: workspaceType,
+            });
+
+          if (!projectAuthToken || !projectAuthToken.authToken) {
+            userStringToAppend = "";
+          } else {
+            const workspaceUsername: string =
+              await this.getUserNameFromWorkspace({
+                userId: workspaceUserToken.workspaceUserId,
+                workspaceType: workspaceType,
+                authToken: projectAuthToken.authToken,
+              });
+
+            userStringToAppend = `@${workspaceUsername} `;
+          }
+        } else {
+          const userstring: string = await UserService.getUserMarkdownString({
+            userId: data.userId,
+            projectId: data.projectId,
+          });
+
+          userStringToAppend = `${userstring} `;
+        }
+      }
+
+      messageBlocksByWorkspaceType.push({
+        workspaceType: workspaceType,
+        messageBlocks: [
+          {
+            _type: "WorkspacePayloadMarkdown",
+            text: userStringToAppend + data.markdown,
+          } as WorkspacePayloadMarkdown,
+        ],
+      });
+    }
+
+    return messageBlocksByWorkspaceType;
+  }
+
+  public static getAllWorkspaceTypes(): Array<WorkspaceType> {
+    const workspaceTypes: Array<WorkspaceType> = [];
+
+    for (const workspaceType in WorkspaceType) {
+      workspaceTypes.push(workspaceType as WorkspaceType);
+    }
+
+    return workspaceTypes;
+  }
+
   public static getWorkspaceTypeUtil(
     workspaceType: WorkspaceType,
   ): typeof WorkspaceBase {
@@ -20,4 +108,109 @@ export default class WorkspaceUtil {
       `Workspace type ${workspaceType} is not supported`,
     );
   }
+
+  public static async getUserNameFromWorkspace(data: {
+    userId: string;
+    workspaceType: WorkspaceType;
+    authToken: string;
+  }): Promise<string> {
+    const userName: string = await WorkspaceUtil.getWorkspaceTypeUtil(
+      data.workspaceType,
+    ).getUsernameFromUserId({
+      userId: data.userId,
+      authToken: data.authToken,
+    });
+
+    return userName;
+  }
+
+  public static async postMessageToAllWorkspaceChannelsAsBot(data: {
+    projectId: ObjectID;
+    messagePayloadsByWorkspace: Array<WorkspaceMessagePayload>;
+  }): Promise<Array<WorkspaceSendMessageResponse>> {
+    logger.debug("postToWorkspaceChannels called with data:");
+    logger.debug(data);
+
+    const responses: Array<WorkspaceSendMessageResponse> = [];
+
+    for (const messagePayloadByWorkspace of data.messagePayloadsByWorkspace) {
+      const projectAuthToken: WorkspaceProjectAuthToken | null =
+        await WorkspaceProjectAuthTokenService.getProjectAuth({
+          projectId: data.projectId,
+          workspaceType: messagePayloadByWorkspace.workspaceType,
+        });
+
+      if (!projectAuthToken) {
+        responses.push({
+          workspaceType: messagePayloadByWorkspace.workspaceType,
+          threads: [],
+        });
+
+        continue;
+      }
+
+      const workspaceType: WorkspaceType =
+        messagePayloadByWorkspace.workspaceType;
+
+      let botUserId: string | undefined = undefined;
+
+      if (workspaceType === WorkspaceType.Slack) {
+        botUserId = (projectAuthToken.miscData as SlackMiscData).botUserId;
+      }
+
+      if (!botUserId) {
+        responses.push({
+          workspaceType: workspaceType,
+          threads: [],
+        });
+        continue;
+      }
+
+      if (!projectAuthToken.authToken) {
+        responses.push({
+          workspaceType: workspaceType,
+          threads: [],
+        });
+        continue;
+      }
+
+      const result: WorkspaceSendMessageResponse =
+        await WorkspaceUtil.getWorkspaceTypeUtil(workspaceType).sendMessage({
+          userId: botUserId,
+          authToken: projectAuthToken.authToken,
+          workspaceMessagePayload: messagePayloadByWorkspace,
+        });
+
+      responses.push(result);
+    }
+
+    logger.debug("Message posted to workspace channels successfully");
+    logger.debug("Returning thread IDs");
+    logger.debug(responses);
+
+    return responses;
+  }
+
+  public static async postToWorkspaceChannels(data: {
+    workspaceUserId: string;
+    projectOrUserAuthTokenForWorkspace: string;
+    workspaceType: WorkspaceType;
+    workspaceMessagePayload: WorkspaceMessagePayload;
+  }): Promise<WorkspaceSendMessageResponse> {
+    logger.debug("postToWorkspaceChannels called with data:");
+    logger.debug(data);
+
+    const result: WorkspaceSendMessageResponse =
+      await WorkspaceUtil.getWorkspaceTypeUtil(data.workspaceType).sendMessage({
+        userId: data.workspaceUserId,
+        workspaceMessagePayload: data.workspaceMessagePayload,
+        authToken: data.projectOrUserAuthTokenForWorkspace,
+      });
+
+    logger.debug("Message posted to workspace channels successfully");
+    logger.debug("Returning thread IDs");
+    logger.debug(result);
+
+    return result;
+  }
 }

package/Server/Utils/Workspace/WorkspaceBase.ts

@@ -5,15 +5,32 @@ import NotImplementedException from "../../../Types/Exception/NotImplementedExce
 import { JSONObject } from "../../../Types/JSON";
 import WorkspaceChannelInvitationPayload from "../../../Types/Workspace/WorkspaceChannelInvitationPayload";
 import WorkspaceMessagePayload, {
+  WorkspaceCheckboxBlock,
+  WorkspaceDropdownBlock,
+  WorkspaceMessageBlock,
   WorkspaceMessagePayloadButton,
+  WorkspaceModalBlock,
   WorkspacePayloadButtons,
   WorkspacePayloadHeader,
+  WorkspacePayloadImage,
   WorkspacePayloadMarkdown,
+  WorkspaceTextAreaBlock,
+  WorkspaceTextBoxBlock,
 } from "../../../Types/Workspace/WorkspaceMessagePayload";
 import WorkspaceType from "../../../Types/Workspace/WorkspaceType";
 import logger from "../Logger";
 import URL from "Common/Types/API/URL";
 
+export interface WorkspaceThread {
+  channel: WorkspaceChannel;
+  threadId: string;
+}
+
+export interface WorkspaceSendMessageResponse {
+  threads: Array<WorkspaceThread>;
+  workspaceType: WorkspaceType;
+}
+
 export interface WorkspaceChannel {
   id: string;
   name: string;
@@ -21,6 +38,42 @@ export interface WorkspaceChannel {
 }
 
 export default class WorkspaceBase {
+  public static async isUserInDirectMessageChannel(_data: {
+    authToken: string;
+    userId: string;
+    directMessageChannelId: string;
+  }): Promise<boolean> {
+    throw new NotImplementedException();
+  }
+  public static async getUsernameFromUserId(_data: {
+    authToken: string;
+    userId: string;
+  }): Promise<string> {
+    throw new NotImplementedException();
+  }
+
+  public static async showModalToUser(_data: {
+    authToken: string;
+    triggerId: string;
+    modalBlock: WorkspaceModalBlock;
+  }): Promise<void> {
+    throw new NotImplementedException();
+  }
+
+  public static getCheckboxBlock(_data: {
+    payloadCheckboxBlock: WorkspaceCheckboxBlock;
+  }): JSONObject {
+    throw new NotImplementedException();
+  }
+
+  public static sendDirectMessageToUser(_data: {
+    authToken: string;
+    workspaceUserId: string;
+    messageBlocks: Array<WorkspaceMessageBlock>;
+  }): Promise<void> {
+    throw new NotImplementedException();
+  }
+
   public static async joinChannel(_data: {
     authToken: string;
     channelId: string;
@@ -30,9 +83,9 @@ export default class WorkspaceBase {
 
   public static async sendPayloadBlocksToChannel(_data: {
     authToken: string;
-    channelId: string;
+    workspaceChannel: WorkspaceChannel;
     blocks: Array<JSONObject>;
-  }): Promise<void> {
+  }): Promise<WorkspaceThread> {
     throw new NotImplementedException();
   }
 
@@ -97,7 +150,7 @@ export default class WorkspaceBase {
     workspaceMessagePayload: WorkspaceMessagePayload;
     authToken: string; // which auth token should we use to send.
     userId: string;
-  }): Promise<void> {
+  }): Promise<WorkspaceSendMessageResponse> {
     throw new NotImplementedException();
   }
 
@@ -127,6 +180,10 @@ export default class WorkspaceBase {
     throw new NotImplementedException();
   }
 
+  public static getDividerBlock(): JSONObject {
+    throw new NotImplementedException();
+  }
+
   public static getMarkdownBlock(_data: {
     payloadMarkdownBlock: WorkspacePayloadMarkdown;
   }): JSONObject {
@@ -139,12 +196,13 @@ export default class WorkspaceBase {
     throw new NotImplementedException();
   }
 
-  public static getBlocksFromWorkspaceMessagePayload(
-    data: WorkspaceMessagePayload,
-  ): Array<JSONObject> {
+  public static getBlocksFromWorkspaceMessagePayload(data: {
+    messageBlocks: Array<WorkspaceMessageBlock>;
+  }): Array<JSONObject> {
+    const { messageBlocks } = data;
+
     const blocks: Array<JSONObject> = [];
-    const buttons: Array<JSONObject> = [];
-    for (const block of data.messageBlocks) {
+    for (const block of messageBlocks) {
       switch (block._type) {
         case "WorkspacePayloadHeader":
           blocks.push(
@@ -160,18 +218,50 @@ export default class WorkspaceBase {
             }),
           );
           break;
+        case "WorkspacePayloadDivider":
+          blocks.push(this.getDividerBlock());
+          break;
         case "WorkspacePayloadButtons":
-          for (const button of (block as WorkspacePayloadButtons).buttons) {
-            buttons.push(
-              this.getButtonBlock({
-                payloadButtonBlock: button,
-              }),
-            );
-          }
-          blocks.push({
-            type: "actions",
-            elements: buttons,
-          });
+          blocks.push(
+            this.getButtonsBlock({
+              payloadButtonsBlock: block as WorkspacePayloadButtons,
+            }),
+          );
+          break;
+        case "WorkspaceTextAreaBlock":
+          blocks.push(
+            this.getTextAreaBlock({
+              payloadTextAreaBlock: block as WorkspaceTextAreaBlock,
+            }),
+          );
+          break;
+        case "WorkspaceTextBoxBlock":
+          blocks.push(
+            this.getTextBoxBlock({
+              payloadTextBoxBlock: block as WorkspaceTextBoxBlock,
+            }),
+          );
+          break;
+        case "WorkspacePayloadImage":
+          blocks.push(
+            this.getImageBlock({
+              payloadImageBlock: block as WorkspacePayloadImage,
+            }),
+          );
+          break;
+        case "WorkspaceDropdownBlock":
+          blocks.push(
+            this.getDropdownBlock({
+              payloadDropdownBlock: block as WorkspaceDropdownBlock,
+            }),
+          );
+          break;
+        case "WorkspaceModalBlock":
+          blocks.push(
+            this.getModalBlock({
+              payloadModalBlock: block as WorkspaceModalBlock,
+            }),
+          );
           break;
         default:
           logger.error("Unknown block type: " + block._type);
@@ -181,6 +271,42 @@ export default class WorkspaceBase {
     return blocks;
   }
 
+  public static getTextAreaBlock(_data: {
+    payloadTextAreaBlock: WorkspaceTextAreaBlock;
+  }): JSONObject {
+    throw new NotImplementedException();
+  }
+
+  public static getTextBoxBlock(_data: {
+    payloadTextBoxBlock: WorkspaceTextBoxBlock;
+  }): JSONObject {
+    throw new NotImplementedException();
+  }
+
+  public static getImageBlock(_data: {
+    payloadImageBlock: WorkspacePayloadImage;
+  }): JSONObject {
+    throw new NotImplementedException();
+  }
+
+  public static getDropdownBlock(_data: {
+    payloadDropdownBlock: WorkspaceDropdownBlock;
+  }): JSONObject {
+    throw new NotImplementedException();
+  }
+
+  public static getModalBlock(_data: {
+    payloadModalBlock: WorkspaceModalBlock;
+  }): JSONObject {
+    throw new NotImplementedException();
+  }
+
+  public static getButtonsBlock(_data: {
+    payloadButtonsBlock: WorkspacePayloadButtons;
+  }): JSONObject {
+    throw new NotImplementedException();
+  }
+
   public static async sendMessageToChannelViaIncomingWebhook(_data: {
     url: URL;
     text: string;

package/Server/Utils/Workspace/WorkspaceMessages/Incident.ts

@@ -0,0 +1,68 @@
+import ObjectID from "../../../../Types/ObjectID";
+import NotificationRuleEventType from "../../../../Types/Workspace/NotificationRules/EventType";
+import NotificationRuleWorkspaceChannel from "../../../../Types/Workspace/NotificationRules/NotificationRuleWorkspaceChannel";
+import { WorkspaceMessageBlock } from "../../../../Types/Workspace/WorkspaceMessagePayload";
+import WorkspaceType from "../../../../Types/Workspace/WorkspaceType";
+import WorkspaceNotificationRuleService, {
+  MessageBlocksByWorkspaceType,
+} from "../../../Services/WorkspaceNotificationRuleService";
+import logger from "../../Logger";
+import SlackIncidentMessages from "../Slack/Messages/Incident";
+
+export default class IncidentWorkspaceMessages {
+  public static async createChannelsAndInviteUsersToChannels(data: {
+    projectId: ObjectID;
+    incidentId: ObjectID;
+    incidentNumber: number;
+  }): Promise<{
+    channelsCreated: NotificationRuleWorkspaceChannel[];
+  } | null> {
+    try {
+      // we will notify the workspace about the incident creation with the bot tokken which is in WorkspaceProjectAuth Table.
+      return await WorkspaceNotificationRuleService.createChannelsAndInviteUsersToChannelsBasedOnRules(
+        {
+          projectId: data.projectId,
+          notificationFor: {
+            incidentId: data.incidentId,
+          },
+          notificationRuleEventType: NotificationRuleEventType.Incident,
+          channelNameSiffix: data.incidentNumber.toString(),
+        },
+      );
+    } catch (err) {
+      // log the error and continue.
+      logger.error(err);
+      return null;
+    }
+  }
+
+  public static async getIncidentCreateMessageBlocks(data: {
+    incidentId: ObjectID;
+    projectId: ObjectID;
+  }): Promise<Array<MessageBlocksByWorkspaceType>> {
+    const { incidentId, projectId } = data;
+
+    const slackBlocks: WorkspaceMessageBlock[] =
+      await SlackIncidentMessages.getIncidentCreateMessageBlocks({
+        incidentId: incidentId,
+        projectId: projectId!,
+      });
+
+    const microsoftTeamsBlocks: WorkspaceMessageBlock[] =
+      await SlackIncidentMessages.getIncidentCreateMessageBlocks({
+        incidentId: incidentId,
+        projectId: projectId!,
+      });
+
+    return [
+      {
+        workspaceType: WorkspaceType.Slack,
+        messageBlocks: slackBlocks,
+      },
+      {
+        workspaceType: WorkspaceType.MicrosoftTeams,
+        messageBlocks: microsoftTeamsBlocks,
+      },
+    ];
+  }
+}

package/Types/Icon/IconProp.ts

@@ -5,6 +5,7 @@ enum IconProp {
   Automation = "Automation",
   Workflow = "Workflow",
   TableCells = "TableCells",
+  MicrosoftTeams = "MicrosoftTeams",
   Layout = "Layout",
   Compass = "Compass",
   ShieldCheck = "ShieldCheck",

package/Types/Workspace/NotificationRules/NotificationRuleCondition.ts

@@ -40,6 +40,7 @@ export enum ConditionType {
   LessThan = "Less Than",
   GreaterThanOrEqualTo = "Greater Than Or Equal To",
   LessThanOrEqualTo = "Less Than Or Equal To",
+  Contains = "Contains",
   ContainsAny = "Contains Any",
   NotContains = "Not Contains",
   StartsWith = "Starts With",
@@ -321,7 +322,7 @@ export class NotificationRuleConditionUtil {
         return [
           ConditionType.EqualTo,
           ConditionType.NotEqualTo,
-          ConditionType.ContainsAny,
+          ConditionType.Contains,
           ConditionType.NotContains,
           ConditionType.StartsWith,
           ConditionType.EndsWith,