@oneuptime/common 7.0.3718 → 7.0.3815

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

@@ -0,0 +1,17 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class MigrationName1740598793630 implements MigrationInterface {
+  public name = "MigrationName1740598793630";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "Incident" RENAME COLUMN "workspaceThreadIds" TO "workspaceSendMessageResponse"`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "Incident" RENAME COLUMN "workspaceSendMessageResponse" TO "workspaceThreadIds"`,
+    );
+  }
+}

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

@@ -0,0 +1,17 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class MigrationName1741031019972 implements MigrationInterface {
+  public name = "MigrationName1741031019972";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "Incident" DROP COLUMN "workspaceSendMessageResponse"`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "Incident" ADD "workspaceSendMessageResponse" jsonb`,
+    );
+  }
+}

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/AccessTokenService.ts

@@ -15,6 +15,7 @@ import TeamMember from "Common/Models/DatabaseModels/TeamMember";
 import TeamPermission from "Common/Models/DatabaseModels/TeamPermission";
 import UserPermissionUtil from "../Utils/UserPermission/UserPermission";
 import PermissionNamespace from "../Types/Permission/PermissionNamespace";
+import DatabaseCommonInteractionProps from "../../Types/BaseDatabase/DatabaseCommonInteractionProps";
 
 export class AccessTokenService extends BaseService {
   public constructor() {
@@ -198,6 +199,26 @@ export class AccessTokenService extends BaseService {
     return permission;
   }
 
+  public async getDatabaseCommonInteractionPropsByUserAndProject(data: {
+    userId: ObjectID;
+    projectId: ObjectID;
+  }): Promise<DatabaseCommonInteractionProps> {
+    const { userId, projectId } = data;
+
+    return {
+      userId: userId,
+      userGlobalAccessPermission:
+        (await this.getUserGlobalAccessPermission(userId)) || undefined,
+      userTenantAccessPermission: {
+        [projectId.toString()]: (await this.getUserTenantAccessPermission(
+          userId,
+          projectId,
+        ))!,
+      },
+      tenantId: projectId,
+    };
+  }
+
   public async getUserTenantAccessPermission(
     userId: ObjectID,
     projectId: ObjectID,

package/Server/Services/AlertFeedService.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 { WorkspaceChannel } from "../Utils/Workspace/WorkspaceBase";
+import AlertService from "./AlertService";
 import DatabaseService from "./DatabaseService";
 import Model, {
   AlertFeedEventType,
 } from "Common/Models/DatabaseModels/AlertFeed";
+import WorkspaceNotificationRuleService, {
+  MessageBlocksByWorkspaceType,
+} from "./WorkspaceNotificationRuleService";
+import NotificationRuleEventType from "../../Types/Workspace/NotificationRules/EventType";
+import WorkspaceUtil from "../Utils/Workspace/Workspace";
+import WorkspaceType from "../../Types/Workspace/WorkspaceType";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
@@ -19,7 +28,7 @@ export class Service extends DatabaseService<Model> {
     }
   }
 
-  public async createAlertFeed(data: {
+  public async createAlertFeedItem(data: {
     alertId: ObjectID;
     feedInfoInMarkdown: string;
     alertFeedEventType: AlertFeedEventType;
@@ -28,6 +37,13 @@ export class Service extends DatabaseService<Model> {
     displayColor?: Color | undefined;
     userId?: ObjectID | undefined;
     postedAt?: Date | undefined;
+    workspaceNotification?:
+      | {
+          notifyUserId?: ObjectID | undefined; // this is oneuptime user id.
+          sendWorkspaceNotification: boolean;
+          appendMessageBlocks?: Array<MessageBlocksByWorkspaceType> | undefined;
+        }
+      | undefined;
   }): Promise<void> {
     try {
       if (!data.alertId) {
@@ -77,8 +93,90 @@ export class Service extends DatabaseService<Model> {
           isRoot: true,
         },
       });
+
+      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.Alert,
+                  workspaceType: messageBlocksByWorkspaceType.workspaceType,
+                },
+              );
+
+            const alertChannels: Array<WorkspaceChannel> =
+              await AlertService.getWorkspaceChannelForAlert({
+                alertId: data.alertId,
+                workspaceType: messageBlocksByWorkspaceType.workspaceType,
+              });
+
+            const workspaceMessagePayload: WorkspaceMessagePayload = {
+              _type: "WorkspaceMessagePayload",
+              workspaceType: messageBlocksByWorkspaceType.workspaceType,
+              messageBlocks: messageBlocksByWorkspaceType.messageBlocks,
+              channelNames: existingChannels,
+              channelIds:
+                alertChannels.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 (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

@@ -6,12 +6,34 @@ import AlertFeedService from "./AlertFeedService";
 import { AlertFeedEventType } from "../../Models/DatabaseModels/AlertFeed";
 import { Blue500 } from "../../Types/BrandColors";
 import { LIMIT_PER_PROJECT } from "../../Types/Database/LimitMax";
+import Alert from "../../Models/DatabaseModels/Alert";
+import AlertService from "./AlertService";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
     super(Model);
   }
 
+  public async addNote(data: {
+    userId: ObjectID;
+    alertId: ObjectID;
+    projectId: ObjectID;
+    note: string;
+  }): Promise<Model> {
+    const internalNote: Model = new Model();
+    internalNote.createdByUserId = data.userId;
+    internalNote.alertId = data.alertId;
+    internalNote.projectId = data.projectId;
+    internalNote.note = data.note;
+
+    return this.create({
+      data: internalNote,
+      props: {
+        isRoot: true,
+      },
+    });
+  }
+
   public override async onCreateSuccess(
     _onCreate: OnCreate<Model>,
     createdItem: Model,
@@ -19,17 +41,27 @@ export class Service extends DatabaseService<Model> {
     const userId: ObjectID | null | undefined =
       createdItem.createdByUserId || createdItem.createdByUser?.id;
 
-    await AlertFeedService.createAlertFeed({
+    const alertId: ObjectID = createdItem.alertId!;
+
+    const alertNumber: number | null = await AlertService.getAlertNumber({
+      alertId: alertId,
+    });
+
+    await AlertFeedService.createAlertFeedItem({
       alertId: createdItem.alertId!,
       projectId: createdItem.projectId!,
       alertFeedEventType: AlertFeedEventType.PrivateNote,
       displayColor: Blue500,
       userId: userId || undefined,
 
-      feedInfoInMarkdown: `**Posted Internal / Private Note**
-  
-  ${createdItem.note}
-            `,
+      feedInfoInMarkdown: `📄 posted **private note** for this [Alert ${alertNumber}](${(await AlertService.getAlertLinkInDashboard(createdItem.projectId!, alertId)).toString()}):
+      
+${createdItem.note}
+                `,
+      workspaceNotification: {
+        sendWorkspaceNotification: true,
+        notifyUserId: userId || undefined,
+      },
     });
 
     return createdItem;
@@ -52,6 +84,10 @@ export class Service extends DatabaseService<Model> {
           projectId: true,
           note: true,
           createdByUserId: true,
+          alert: {
+            projectId: true,
+            alertNumber: true,
+          },
           createdByUser: {
             _id: true,
           },
@@ -62,17 +98,22 @@ export class Service extends DatabaseService<Model> {
         onUpdate.updateBy.props.userId;
 
       for (const updatedItem of updatedItems) {
-        await AlertFeedService.createAlertFeed({
+        const alert: Alert = updatedItem.alert!;
+        await AlertFeedService.createAlertFeedItem({
           alertId: updatedItem.alertId!,
           projectId: updatedItem.projectId!,
           alertFeedEventType: AlertFeedEventType.PrivateNote,
           displayColor: Blue500,
           userId: userId || undefined,
 
-          feedInfoInMarkdown: `**Updated Internal / Private Note**
-  
-  ${updatedItem.note}
-            `,
+          feedInfoInMarkdown: `📄 updated **Private Note** for this [Alert ${alert.alertNumber}](${(await AlertService.getAlertLinkInDashboard(alert.projectId!, alert.id!)).toString()})
+          
+${updatedItem.note}
+                    `,
+          workspaceNotification: {
+            sendWorkspaceNotification: true,
+            notifyUserId: userId || undefined,
+          },
         });
       }
     }

package/Server/Services/AlertOwnerTeamService.ts

@@ -8,6 +8,11 @@ import TeamService from "./TeamService";
 import AlertFeedService from "./AlertFeedService";
 import { AlertFeedEventType } from "../../Models/DatabaseModels/AlertFeed";
 import { Gray500, Red500 } from "../../Types/BrandColors";
+import AlertService from "./AlertService";
+import WorkspaceNotificationRule from "../../Models/DatabaseModels/WorkspaceNotificationRule";
+import WorkspaceNotificationRuleService from "./WorkspaceNotificationRuleService";
+import NotificationRuleEventType from "../../Types/Workspace/NotificationRules/EventType";
+import logger from "../Utils/Logger";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
@@ -65,13 +70,20 @@ export class Service extends DatabaseService<Model> {
         });
 
         if (team && team.name) {
-          await AlertFeedService.createAlertFeed({
+          const alertNumber: number | null = await AlertService.getAlertNumber({
+            alertId: alertId,
+          });
+          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 ${alertNumber}](${(await AlertService.getAlertLinkInDashboard(projectId!, alertId!)).toString()}) as the owner.`,
             userId: deleteByUserId || undefined,
+            workspaceNotification: {
+              sendWorkspaceNotification: true,
+              notifyUserId: deleteByUserId || undefined,
+            },
           });
         }
       }
@@ -104,17 +116,53 @@ export class Service extends DatabaseService<Model> {
       });
 
       if (team && team.name) {
-        await AlertFeedService.createAlertFeed({
+        const alertNumber: number | null = await AlertService.getAlertNumber({
+          alertId: alertId,
+        });
+
+        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 ${alertNumber}](${(await AlertService.getAlertLinkInDashboard(projectId!, alertId!)).toString()}) as the owner.`,
           userId: createdByUserId || undefined,
+          workspaceNotification: {
+            sendWorkspaceNotification: true,
+            notifyUserId: createdByUserId || undefined,
+          },
         });
       }
     }
 
+    // get notification rule where inviteOwners is true.
+    const notificationRules: Array<WorkspaceNotificationRule> =
+      await WorkspaceNotificationRuleService.getNotificationRulesWhereInviteOwnersIsTrue(
+        {
+          projectId: projectId!,
+          notificationFor: {
+            alertId: alertId,
+          },
+          notificationRuleEventType: NotificationRuleEventType.Alert,
+        },
+      );
+
+    logger.debug(`Notification Rules for Alert Owner Teams`);
+    logger.debug(notificationRules);
+
+    WorkspaceNotificationRuleService.inviteTeamsBasedOnRulesAndWorkspaceChannels(
+      {
+        notificationRules: notificationRules,
+        projectId: projectId!,
+        workspaceChannels: await AlertService.getWorkspaceChannelForAlert({
+          alertId: alertId!,
+        }),
+        teamIds: [teamId!],
+      },
+    ).catch((error: Error) => {
+      logger.error(error);
+    });
+
     return createdItem;
   }
 }

package/Server/Services/AlertOwnerUserService.ts

@@ -8,6 +8,11 @@ import UserService from "./UserService";
 import AlertFeedService from "./AlertFeedService";
 import { AlertFeedEventType } from "../../Models/DatabaseModels/AlertFeed";
 import { Gray500, Red500 } from "../../Types/BrandColors";
+import AlertService from "./AlertService";
+import WorkspaceNotificationRule from "../../Models/DatabaseModels/WorkspaceNotificationRule";
+import WorkspaceNotificationRuleService from "./WorkspaceNotificationRuleService";
+import NotificationRuleEventType from "../../Types/Workspace/NotificationRules/EventType";
+import logger from "../Utils/Logger";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
@@ -66,13 +71,21 @@ export class Service extends DatabaseService<Model> {
         });
 
         if (user && user.name) {
-          await AlertFeedService.createAlertFeed({
+          const alertNumber: number | null = await AlertService.getAlertNumber({
+            alertId: alertId,
+          });
+
+          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 ${alertNumber}](${(await AlertService.getAlertLinkInDashboard(projectId!, alertId!)).toString()}) as the owner.`,
             userId: deleteByUserId || undefined,
+            workspaceNotification: {
+              sendWorkspaceNotification: true,
+              notifyUserId: userId || undefined,
+            },
           });
         }
       }
@@ -106,17 +119,54 @@ export class Service extends DatabaseService<Model> {
       });
 
       if (user && user.name) {
-        await AlertFeedService.createAlertFeed({
+        const alertNumber: number | null = await AlertService.getAlertNumber({
+          alertId: alertId,
+        });
+        await AlertFeedService.createAlertFeedItem({
           alertId: alertId,
           projectId: projectId,
           alertFeedEventType: AlertFeedEventType.OwnerUserAdded,
           displayColor: Gray500,
-          feedInfoInMarkdown: `**${user.name.toString()}** (${user.email?.toString()}) was added to the alert as the owner.`,
+          feedInfoInMarkdown: `👨🏻‍💻 Added **${await UserService.getUserMarkdownString(
+            {
+              userId: userId,
+              projectId: projectId,
+            },
+          )}** to the [Alert ${alertNumber}](${(await AlertService.getAlertLinkInDashboard(projectId!, alertId!)).toString()}) as the owner.`,
           userId: createdByUserId || undefined,
+          workspaceNotification: {
+            sendWorkspaceNotification: true,
+            notifyUserId: userId || undefined,
+          },
         });
       }
     }
 
+    // get notification rule where inviteOwners is true.
+    const notificationRules: Array<WorkspaceNotificationRule> =
+      await WorkspaceNotificationRuleService.getNotificationRulesWhereInviteOwnersIsTrue(
+        {
+          projectId: projectId!,
+          notificationFor: {
+            alertId: alertId,
+          },
+          notificationRuleEventType: NotificationRuleEventType.Alert,
+        },
+      );
+
+    WorkspaceNotificationRuleService.inviteUsersBasedOnRulesAndWorkspaceChannels(
+      {
+        notificationRules: notificationRules,
+        projectId: projectId!,
+        workspaceChannels: await AlertService.getWorkspaceChannelForAlert({
+          alertId: alertId!,
+        }),
+        userIds: [userId!],
+      },
+    ).catch((error: Error) => {
+      logger.error(error);
+    });
+
     return createdItem;
   }
 }