@oneuptime/common 7.0.3718 → 7.0.3786

package/Server/Infrastructure/Postgres/SchemaMigrations/1741209339971-MigrationName.ts

@@ -0,0 +1,101 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class MigrationName1741209339971 implements MigrationInterface {
+  public name = "MigrationName1741209339971";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `CREATE TABLE "ProjectUser" ("_id" uuid NOT NULL DEFAULT uuid_generate_v4(), "createdAt" TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT now(), "updatedAt" TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT now(), "deletedAt" TIMESTAMP WITH TIME ZONE, "version" integer NOT NULL, "projectId" uuid NOT NULL, "userId" uuid NOT NULL, "createdByUserId" uuid, "deletedByUserId" uuid, CONSTRAINT "PK_912199af7fc0be254b07b37306b" PRIMARY KEY ("_id"))`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_770271904cf388001552bc4755" ON "ProjectUser" ("projectId") `,
+    );
+    await queryRunner.query(
+      `CREATE TABLE "ProjectUserAcceptedTeams" ("projectUserId" uuid NOT NULL, "teamId" uuid NOT NULL, CONSTRAINT "PK_93ca44f68c74f4a859f2bcf260f" PRIMARY KEY ("projectUserId", "teamId"))`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_54f5c1c6cf385ffa6094430027" ON "ProjectUserAcceptedTeams" ("projectUserId") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_e1731fb8a4540127d98fd28796" ON "ProjectUserAcceptedTeams" ("teamId") `,
+    );
+    await queryRunner.query(
+      `CREATE TABLE "ProjectUserInvitedTeams" ("projectUserId" uuid NOT NULL, "teamId" uuid NOT NULL, CONSTRAINT "PK_59cc028549a2c4e35005277a507" PRIMARY KEY ("projectUserId", "teamId"))`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_baa3a99d9c899e2e59c545e288" ON "ProjectUserInvitedTeams" ("projectUserId") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_aa26c583621dab66eebfba67a4" ON "ProjectUserInvitedTeams" ("teamId") `,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ProjectUser" ADD CONSTRAINT "FK_770271904cf388001552bc47559" FOREIGN KEY ("projectId") REFERENCES "Project"("_id") ON DELETE CASCADE ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ProjectUser" ADD CONSTRAINT "FK_b2a608caefe7d8206517083d856" FOREIGN KEY ("userId") REFERENCES "User"("_id") ON DELETE CASCADE ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ProjectUser" ADD CONSTRAINT "FK_c4aa1af08370547825f1c76f70a" FOREIGN KEY ("createdByUserId") REFERENCES "User"("_id") ON DELETE SET NULL ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ProjectUser" ADD CONSTRAINT "FK_4a79e6f07a902e997f254c8c7eb" FOREIGN KEY ("deletedByUserId") REFERENCES "User"("_id") ON DELETE SET NULL ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ProjectUserAcceptedTeams" ADD CONSTRAINT "FK_54f5c1c6cf385ffa60944300270" FOREIGN KEY ("projectUserId") REFERENCES "ProjectUser"("_id") ON DELETE CASCADE ON UPDATE CASCADE`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ProjectUserAcceptedTeams" ADD CONSTRAINT "FK_e1731fb8a4540127d98fd28796c" FOREIGN KEY ("teamId") REFERENCES "Team"("_id") ON DELETE CASCADE ON UPDATE CASCADE`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ProjectUserInvitedTeams" ADD CONSTRAINT "FK_baa3a99d9c899e2e59c545e288b" FOREIGN KEY ("projectUserId") REFERENCES "ProjectUser"("_id") ON DELETE CASCADE ON UPDATE CASCADE`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ProjectUserInvitedTeams" ADD CONSTRAINT "FK_aa26c583621dab66eebfba67a44" FOREIGN KEY ("teamId") REFERENCES "Team"("_id") ON DELETE CASCADE ON UPDATE CASCADE`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "ProjectUserInvitedTeams" DROP CONSTRAINT "FK_aa26c583621dab66eebfba67a44"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ProjectUserInvitedTeams" DROP CONSTRAINT "FK_baa3a99d9c899e2e59c545e288b"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ProjectUserAcceptedTeams" DROP CONSTRAINT "FK_e1731fb8a4540127d98fd28796c"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ProjectUserAcceptedTeams" DROP CONSTRAINT "FK_54f5c1c6cf385ffa60944300270"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ProjectUser" DROP CONSTRAINT "FK_4a79e6f07a902e997f254c8c7eb"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ProjectUser" DROP CONSTRAINT "FK_c4aa1af08370547825f1c76f70a"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ProjectUser" DROP CONSTRAINT "FK_b2a608caefe7d8206517083d856"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ProjectUser" DROP CONSTRAINT "FK_770271904cf388001552bc47559"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_aa26c583621dab66eebfba67a4"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_baa3a99d9c899e2e59c545e288"`,
+    );
+    await queryRunner.query(`DROP TABLE "ProjectUserInvitedTeams"`);
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_e1731fb8a4540127d98fd28796"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_54f5c1c6cf385ffa6094430027"`,
+    );
+    await queryRunner.query(`DROP TABLE "ProjectUserAcceptedTeams"`);
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_770271904cf388001552bc4755"`,
+    );
+    await queryRunner.query(`DROP TABLE "ProjectUser"`);
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/Index.ts

@@ -108,6 +108,10 @@ import { MigrationName1739569321582 } from "./1739569321582-MigrationName";
 import { MigrationName1740164199817 } from "./1740164199817-MigrationName";
 import { MigrationName1740419151825 } from "./1740419151825-MigrationName";
 import { MigrationName1740430229844 } from "./1740430229844-MigrationName";
+import { MigrationName1740597525803 } from "./1740597525803-MigrationName";
+import { MigrationName1740598793630 } from "./1740598793630-MigrationName";
+import { MigrationName1741031019972 } from "./1741031019972-MigrationName";
+import { MigrationName1741209339971 } from "./1741209339971-MigrationName";
 
 export default [
   InitialMigration,
@@ -220,4 +224,8 @@ export default [
   MigrationName1740164199817,
   MigrationName1740419151825,
   MigrationName1740430229844,
+  MigrationName1740597525803,
+  MigrationName1740598793630,
+  MigrationName1741031019972,
+  MigrationName1741209339971,
 ];

package/Server/Middleware/SlackAuthorization.ts

@@ -15,7 +15,10 @@ export default class SlackAuthorization {
     res: ExpressResponse,
     next: NextFunction,
   ): Promise<void> {
+    logger.debug("Starting Slack request authorization");
+
     if (!SlackAppSigningSecret) {
+      logger.error("SLACK_APP_SIGNING_SECRET env variable not found.");
       return Response.sendErrorResponse(
         req,
         res,
@@ -32,15 +35,19 @@ export default class SlackAuthorization {
     const timestamp: string = req.headers[
       "x-slack-request-timestamp"
     ] as string;
-    const requestBody: string = req.body;
+    const requestBody: string =
+      (req as OneUptimeRequest).rawFormUrlEncodedBody || "";
 
     logger.debug(`slackSignature: ${slackSignature}`);
     logger.debug(`timestamp: ${timestamp}`);
-    logger.debug(`requestBody: ${requestBody}`);
+    logger.debug(`requestBody: `);
+    logger.debug(requestBody);
 
     const baseString: string = `v0:${timestamp}:${requestBody}`;
     const signature: string = `v0=${crypto.createHmac("sha256", slackSigningSecret).update(baseString).digest("hex")}`;
 
+    logger.debug(`Generated signature: ${signature}`);
+
     // check if the signature is valid
     if (
       !crypto.timingSafeEqual(
@@ -48,6 +55,7 @@ export default class SlackAuthorization {
         Buffer.from(slackSignature),
       )
     ) {
+      logger.error("Slack Signature Verification Failed.");
       return Response.sendErrorResponse(
         req,
         res,
@@ -55,6 +63,7 @@ export default class SlackAuthorization {
       );
     }
 
+    logger.debug("Slack request authorized successfully");
     next();
   }
 }

package/Server/Services/AlertFeedService.ts

@@ -19,7 +19,7 @@ export class Service extends DatabaseService<Model> {
     }
   }
 
-  public async createAlertFeed(data: {
+  public async createAlertFeedItem(data: {
     alertId: ObjectID;
     feedInfoInMarkdown: string;
     alertFeedEventType: AlertFeedEventType;
@@ -78,7 +78,7 @@ export class Service extends DatabaseService<Model> {
         },
       });
     } catch (error) {
-      logger.error("AlertFeedService.createAlertFeed");
+      logger.error("AlertFeedService.createAlertFeedItem");
       logger.error(error);
       // we dont want to throw the error here, as this is a non-critical operation
     }

package/Server/Services/AlertInternalNoteService.ts

@@ -19,7 +19,7 @@ export class Service extends DatabaseService<Model> {
     const userId: ObjectID | null | undefined =
       createdItem.createdByUserId || createdItem.createdByUser?.id;
 
-    await AlertFeedService.createAlertFeed({
+    await AlertFeedService.createAlertFeedItem({
       alertId: createdItem.alertId!,
       projectId: createdItem.projectId!,
       alertFeedEventType: AlertFeedEventType.PrivateNote,
@@ -62,7 +62,7 @@ export class Service extends DatabaseService<Model> {
         onUpdate.updateBy.props.userId;
 
       for (const updatedItem of updatedItems) {
-        await AlertFeedService.createAlertFeed({
+        await AlertFeedService.createAlertFeedItem({
           alertId: updatedItem.alertId!,
           projectId: updatedItem.projectId!,
           alertFeedEventType: AlertFeedEventType.PrivateNote,

package/Server/Services/AlertOwnerTeamService.ts

@@ -65,12 +65,12 @@ export class Service extends DatabaseService<Model> {
         });
 
         if (team && team.name) {
-          await AlertFeedService.createAlertFeed({
+          await AlertFeedService.createAlertFeedItem({
             alertId: alertId,
             projectId: projectId,
             alertFeedEventType: AlertFeedEventType.OwnerTeamRemoved,
             displayColor: Red500,
-            feedInfoInMarkdown: `**Team ${team.name}** was removed from the alert as the owner.`,
+            feedInfoInMarkdown: `Removed team **${team.name}** from the alert as the owner.`,
             userId: deleteByUserId || undefined,
           });
         }
@@ -104,12 +104,12 @@ export class Service extends DatabaseService<Model> {
       });
 
       if (team && team.name) {
-        await AlertFeedService.createAlertFeed({
+        await AlertFeedService.createAlertFeedItem({
           alertId: alertId,
           projectId: projectId,
           alertFeedEventType: AlertFeedEventType.OwnerTeamAdded,
           displayColor: Gray500,
-          feedInfoInMarkdown: `**Team ${team.name}** was added to the alert as the owner.`,
+          feedInfoInMarkdown: `Added team **${team.name}** to the alert as the owner.`,
           userId: createdByUserId || undefined,
         });
       }

package/Server/Services/AlertOwnerUserService.ts

@@ -66,12 +66,12 @@ export class Service extends DatabaseService<Model> {
         });
 
         if (user && user.name) {
-          await AlertFeedService.createAlertFeed({
+          await AlertFeedService.createAlertFeedItem({
             alertId: alertId,
             projectId: projectId,
             alertFeedEventType: AlertFeedEventType.OwnerUserRemoved,
             displayColor: Red500,
-            feedInfoInMarkdown: `**${user.name.toString()}** (${user.email?.toString()}) was removed from the alert as the owner.`,
+            feedInfoInMarkdown: `Removed **${user.name.toString()}** (${user.email?.toString()}) from the alert as the owner.`,
             userId: deleteByUserId || undefined,
           });
         }
@@ -106,7 +106,7 @@ export class Service extends DatabaseService<Model> {
       });
 
       if (user && user.name) {
-        await AlertFeedService.createAlertFeed({
+        await AlertFeedService.createAlertFeedItem({
           alertId: alertId,
           projectId: projectId,
           alertFeedEventType: AlertFeedEventType.OwnerUserAdded,

package/Server/Services/AlertService.ts

@@ -45,6 +45,8 @@ import Label from "../../Models/DatabaseModels/Label";
 import LabelService from "./LabelService";
 import AlertSeverity from "../../Models/DatabaseModels/AlertSeverity";
 import AlertSeverityService from "./AlertSeverityService";
+import WorkspaceType from "../../Types/Workspace/WorkspaceType";
+import NotificationRuleWorkspaceChannel from "../../Types/Workspace/NotificationRules/NotificationRuleWorkspaceChannel";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
@@ -229,22 +231,13 @@ export class Service extends DatabaseService<Model> {
         userId = createBy.data.createdByUser.id;
       }
 
-      const user: User | null = await UserService.findOneBy({
-        query: {
-          _id: userId?.toString() as string,
-        },
-        select: {
-          _id: true,
-          name: true,
-          email: true,
-        },
-        props: {
-          isRoot: true,
-        },
-      });
-
-      if (user) {
-        createBy.data.rootCause = `Alert created by ${user.name} (${user.email})`;
+      if (userId) {
+        createBy.data.rootCause = `Alert created by ${await UserService.getUserMarkdownString(
+          {
+            userId: userId!,
+            projectId: projectId,
+          },
+        )}`;
       }
     }
 
@@ -270,7 +263,7 @@ export class Service extends DatabaseService<Model> {
     const createdByUserId: ObjectID | undefined | null =
       createdItem.createdByUserId || createdItem.createdByUser?.id;
 
-    await AlertFeedService.createAlertFeed({
+    await AlertFeedService.createAlertFeedItem({
       alertId: createdItem.id!,
       projectId: createdItem.projectId!,
       alertFeedEventType: AlertFeedEventType.AlertCreated,
@@ -289,7 +282,7 @@ export class Service extends DatabaseService<Model> {
       userId: createdByUserId || undefined,
     });
 
-    await AlertFeedService.createAlertFeed({
+    await AlertFeedService.createAlertFeedItem({
       alertId: createdItem.id!,
       projectId: createdItem.projectId!,
       alertFeedEventType: AlertFeedEventType.RootCause,
@@ -299,7 +292,7 @@ export class Service extends DatabaseService<Model> {
 ${createdItem.rootCause || "No root cause provided."}`,
     });
 
-    await AlertFeedService.createAlertFeed({
+    await AlertFeedService.createAlertFeedItem({
       alertId: createdItem.id!,
       projectId: createdItem.projectId!,
       alertFeedEventType: AlertFeedEventType.RemediationNotes,
@@ -358,6 +351,35 @@ ${createdItem.remediationNotes || "No remediation notes provided."}`,
     return createdItem;
   }
 
+  public async getWorkspaceChannelForAlert(data: {
+    alertId: ObjectID;
+    workspaceType?: WorkspaceType | null;
+  }): Promise<Array<NotificationRuleWorkspaceChannel>> {
+    const alert: Model | null = await this.findOneById({
+      id: data.alertId,
+      select: {
+        postUpdatesToWorkspaceChannels: true,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    if (!alert) {
+      throw new BadDataException("Incident not found.");
+    }
+
+    return (alert.postUpdatesToWorkspaceChannels || []).filter(
+      (channel: NotificationRuleWorkspaceChannel) => {
+        if (!data.workspaceType) {
+          return true;
+        }
+
+        return channel.workspaceType === data.workspaceType;
+      },
+    );
+  }
+
   public async getAlertIdentifiedDate(alertId: ObjectID): Promise<Date> {
     const timeline: AlertStateTimeline | null =
       await AlertStateTimelineService.findOneBy({
@@ -652,7 +674,7 @@ ${alertSeverity.name}
         }
 
         if (shouldAddAlertFeed) {
-          await AlertFeedService.createAlertFeed({
+          await AlertFeedService.createAlertFeedItem({
             alertId: alertId,
             projectId: onUpdate.updateBy.props.tenantId as ObjectID,
             alertFeedEventType: AlertFeedEventType.AlertUpdated,
@@ -1053,5 +1075,25 @@ ${alertSeverity.name}
       logger.error(err);
     });
   }
+
+  public async getAlertNumber(data: {
+    alertId: ObjectID;
+  }): Promise<number | null> {
+    const alert: Model | null = await this.findOneById({
+      id: data.alertId,
+      select: {
+        alertNumber: true,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    if (!alert) {
+      throw new BadDataException("Alert not found.");
+    }
+
+    return alert.alertNumber || null;
+  }
 }
 export default new Service();

package/Server/Services/AlertStateTimelineService.ts

@@ -13,7 +13,6 @@ import ObjectID from "../../Types/ObjectID";
 import PositiveNumber from "../../Types/PositiveNumber";
 import AlertState from "Common/Models/DatabaseModels/AlertState";
 import AlertStateTimeline from "Common/Models/DatabaseModels/AlertStateTimeline";
-import User from "Common/Models/DatabaseModels/User";
 import { IsBillingEnabled } from "../EnvironmentConfig";
 import { JSONObject } from "../../Types/JSON";
 import AlertInternalNote from "../../Models/DatabaseModels/AlertInternalNote";
@@ -80,22 +79,13 @@ export class Service extends DatabaseService<AlertStateTimeline> {
         userId = createBy.data.createdByUser.id;
       }
 
-      const user: User | null = await UserService.findOneBy({
-        query: {
-          _id: userId?.toString() as string,
-        },
-        select: {
-          _id: true,
-          name: true,
-          email: true,
-        },
-        props: {
-          isRoot: true,
-        },
-      });
-
-      if (user) {
-        createBy.data.rootCause = `Alert state created by ${user.name} (${user.email})`;
+      if (userId) {
+        createBy.data.rootCause = `Alert state created by ${await UserService.getUserMarkdownString(
+          {
+            userId: userId,
+            projectId: createBy.data.projectId || createBy.props.tenantId!,
+          },
+        )}`;
       }
     }
 
@@ -190,7 +180,7 @@ export class Service extends DatabaseService<AlertStateTimeline> {
 
     const stateName: string = alertState?.name || "";
 
-    await AlertFeedService.createAlertFeed({
+    await AlertFeedService.createAlertFeedItem({
       alertId: createdItem.alertId!,
       projectId: createdItem.projectId!,
       alertFeedEventType: AlertFeedEventType.AlertStateChanged,

package/Server/Services/IncidentFeedService.ts

@@ -3,12 +3,21 @@ import Color from "../../Types/Color";
 import OneUptimeDate from "../../Types/Date";
 import BadDataException from "../../Types/Exception/BadDataException";
 import ObjectID from "../../Types/ObjectID";
+import WorkspaceMessagePayload from "../../Types/Workspace/WorkspaceMessagePayload";
 import { IsBillingEnabled } from "../EnvironmentConfig";
 import logger from "../Utils/Logger";
 import DatabaseService from "./DatabaseService";
 import IncidentFeed, {
   IncidentFeedEventType,
 } from "Common/Models/DatabaseModels/IncidentFeed";
+import WorkspaceNotificationRuleService, {
+  MessageBlocksByWorkspaceType,
+} from "./WorkspaceNotificationRuleService";
+import NotificationRuleEventType from "../../Types/Workspace/NotificationRules/EventType";
+import IncidentService from "./IncidentService";
+import { WorkspaceChannel } from "../Utils/Workspace/WorkspaceBase";
+import WorkspaceUtil from "../Utils/Workspace/Workspace";
+import WorkspaceType from "../../Types/Workspace/WorkspaceType";
 
 export class Service extends DatabaseService<IncidentFeed> {
   public constructor() {
@@ -19,7 +28,7 @@ export class Service extends DatabaseService<IncidentFeed> {
     }
   }
 
-  public async createIncidentFeed(data: {
+  public async createIncidentFeedItem(data: {
     incidentId: ObjectID;
     feedInfoInMarkdown: string;
     incidentFeedEventType: IncidentFeedEventType;
@@ -28,9 +37,17 @@ export class Service extends DatabaseService<IncidentFeed> {
     displayColor?: Color | undefined;
     userId?: ObjectID | undefined;
     postedAt?: Date | undefined;
+    // send notifificatin to slack and teams. This is optional
+    workspaceNotification?:
+      | {
+          notifyUserId?: ObjectID | undefined; // this is oneuptime user id.
+          sendWorkspaceNotification: boolean;
+          appendMessageBlocks?: Array<MessageBlocksByWorkspaceType> | undefined;
+        }
+      | undefined;
   }): Promise<void> {
     try {
-      logger.debug("IncidentFeedService.createIncidentFeed");
+      logger.debug("IncidentFeedService.createIncidentFeedItem");
       logger.debug(data);
 
       const incidentFeed: IncidentFeed = new IncidentFeed();
@@ -82,6 +99,88 @@ export class Service extends DatabaseService<IncidentFeed> {
 
       logger.debug("Incident Feed created");
       logger.debug(createdIncidentFeed);
+
+      try {
+        // send notification to slack and teams
+        if (data.workspaceNotification?.sendWorkspaceNotification) {
+          let messageBlocksByWorkspaceTypes: Array<MessageBlocksByWorkspaceType> =
+            [];
+
+          // use markdown to create blocks
+          messageBlocksByWorkspaceTypes =
+            await WorkspaceUtil.getMessageBlocksByMarkdown({
+              userId: data.workspaceNotification.notifyUserId,
+              markdown: data.feedInfoInMarkdown,
+              projectId: data.projectId,
+            });
+
+          if (data.workspaceNotification.appendMessageBlocks) {
+            for (const messageBlocksByWorkspaceType of data
+              .workspaceNotification.appendMessageBlocks) {
+              const workspaceType: WorkspaceType =
+                messageBlocksByWorkspaceType.workspaceType;
+
+              messageBlocksByWorkspaceTypes
+                .find(
+                  (
+                    messageBlocksByWorkspaceType: MessageBlocksByWorkspaceType,
+                  ) => {
+                    return (
+                      messageBlocksByWorkspaceType.workspaceType ===
+                      workspaceType
+                    );
+                  },
+                )
+                ?.messageBlocks.push(
+                  ...messageBlocksByWorkspaceType.messageBlocks,
+                );
+            }
+          }
+
+          const workspaceNotificationPaylaods: Array<WorkspaceMessagePayload> =
+            [];
+
+          for (const messageBlocksByWorkspaceType of messageBlocksByWorkspaceTypes) {
+            const existingChannels: Array<string> =
+              await WorkspaceNotificationRuleService.getExistingChannelNamesBasedOnEventType(
+                {
+                  projectId: data.projectId,
+                  notificationRuleEventType: NotificationRuleEventType.Incident,
+                  workspaceType: messageBlocksByWorkspaceType.workspaceType,
+                },
+              );
+
+            const incidentChannels: Array<WorkspaceChannel> =
+              await IncidentService.getWorkspaceChannelForIncident({
+                incidentId: data.incidentId,
+                workspaceType: messageBlocksByWorkspaceType.workspaceType,
+              });
+
+            const workspaceMessagePayload: WorkspaceMessagePayload = {
+              _type: "WorkspaceMessagePayload",
+              workspaceType: messageBlocksByWorkspaceType.workspaceType,
+              messageBlocks: messageBlocksByWorkspaceType.messageBlocks,
+              channelNames: existingChannels,
+              channelIds:
+                incidentChannels.map((channel: WorkspaceChannel) => {
+                  return channel.id;
+                }) || [],
+            };
+
+            workspaceNotificationPaylaods.push(workspaceMessagePayload);
+          }
+
+          await WorkspaceUtil.postMessageToAllWorkspaceChannelsAsBot({
+            projectId: data.projectId,
+            messagePayloadsByWorkspace: workspaceNotificationPaylaods,
+          });
+        }
+      } catch (e) {
+        logger.error("Error in sending notification to slack and teams");
+        logger.error(e);
+
+        // we dont throw this error as it is not a critical error
+      }
     } catch (e) {
       logger.error("Error in creating incident feed");
       logger.error(e);