@oneuptime/common 7.0.3717 → 7.0.3786

package/Server/Services/WorkspaceNotificationRuleService.ts

@@ -2,7 +2,6 @@ import ObjectID from "../../Types/ObjectID";
 import NotificationRuleEventType from "../../Types/Workspace/NotificationRules/EventType";
 import WorkspaceType from "../../Types/Workspace/WorkspaceType";
 import DatabaseService from "./DatabaseService";
-import Model from "Common/Models/DatabaseModels/WorkspaceNotificationRule";
 import IncidentNotificationRule from "../../Types/Workspace/NotificationRules/NotificationRuleTypes/IncidentNotificationRule";
 import { LIMIT_PER_PROJECT } from "../../Types/Database/LimitMax";
 import Incident from "../../Models/DatabaseModels/Incident";
@@ -26,8 +25,9 @@ import { WorkspaceChannel } from "../Utils/Workspace/WorkspaceBase";
 import WorkspaceUtil from "../Utils/Workspace/Workspace";
 import WorkspaceUserAuthToken from "../../Models/DatabaseModels/WorkspaceUserAuthToken";
 import WorkspaceUserAuthTokenService from "./WorkspaceUserAuthTokenService";
-import WorkspaceMessagePayload, {
+import {
   WorkspaceMessageBlock,
+  WorkspacePayloadMarkdown,
 } from "../../Types/Workspace/WorkspaceMessagePayload";
 import WorkspaceProjectAuthToken, {
   MiscData,
@@ -35,6 +35,14 @@ import WorkspaceProjectAuthToken, {
 } from "../../Models/DatabaseModels/WorkspaceProjectAuthToken";
 import WorkspaceProjectAuthTokenService from "./WorkspaceProjectAuthTokenService";
 import logger from "../Utils/Logger";
+import NotificationRuleWorkspaceChannel from "../../Types/Workspace/NotificationRules/NotificationRuleWorkspaceChannel";
+import WorkspaceNotificationRule from "Common/Models/DatabaseModels/WorkspaceNotificationRule";
+import UserService from "./UserService";
+
+export interface MessageBlocksByWorkspaceType {
+  workspaceType: WorkspaceType;
+  messageBlocks: Array<WorkspaceMessageBlock>;
+}
 
 export interface NotificationFor {
   incidentId?: ObjectID | undefined;
@@ -43,9 +51,13 @@ export interface NotificationFor {
   monitorStatusTimelineId?: ObjectID | undefined;
 }
 
-export class Service extends DatabaseService<Model> {
+export class Service extends DatabaseService<WorkspaceNotificationRule> {
   public constructor() {
-    super(Model);
+    super(WorkspaceNotificationRule);
+  }
+
+  public static getAllWorkspaceTypes(): Array<WorkspaceType> {
+    return [WorkspaceType.Slack, WorkspaceType.MicrosoftTeams];
   }
 
   public getBotUserIdFromprojectAuthToken(data: {
@@ -73,21 +85,53 @@ export class Service extends DatabaseService<Model> {
     throw new BadDataException("Workspace type not supported");
   }
 
-  public async createInviteAndPostToChannelsBasedOnRules(data: {
+  public async getExistingChannelNamesBasedOnEventType(data: {
+    projectId: ObjectID;
+    workspaceType: WorkspaceType;
+    notificationRuleEventType: NotificationRuleEventType;
+  }): Promise<Array<string>> {
+    logger.debug("getExistingChannelNamesBasedOnEventType called with data:");
+    logger.debug(data);
+
+    const notificationRules: Array<WorkspaceNotificationRule> =
+      await this.getNotificationRules({
+        projectId: data.projectId,
+        workspaceType: data.workspaceType,
+        notificationRuleEventType: data.notificationRuleEventType,
+      });
+
+    logger.debug("Notification rules retrieved:");
+    logger.debug(notificationRules);
+
+    const existingChannelNames: Array<string> =
+      this.getExistingChannelNamesFromNotificationRules({
+        notificationRules: notificationRules.map(
+          (rule: WorkspaceNotificationRule) => {
+            return rule.notificationRule as BaseNotificationRule;
+          },
+        ),
+      }) || [];
+
+    logger.debug("Existing channel names:");
+    logger.debug(existingChannelNames);
+
+    return existingChannelNames;
+  }
+
+  public async createChannelsAndInviteUsersToChannelsBasedOnRules(data: {
     projectId: ObjectID;
     notificationRuleEventType: NotificationRuleEventType;
     notificationFor: NotificationFor;
     channelNameSiffix: string;
-    messageBlocks: Array<WorkspaceMessageBlock>;
   }): Promise<{
-    channelsCreated: Array<WorkspaceChannel>;
+    channelsCreated: Array<NotificationRuleWorkspaceChannel>;
   } | null> {
     logger.debug(
       "WorkspaceNotificationRuleService.createInviteAndPostToChannelsBasedOnRules",
     );
     logger.debug(data);
 
-    const channelsCreated: Array<WorkspaceChannel> = [];
+    const channelsCreated: Array<NotificationRuleWorkspaceChannel> = [];
 
     const projectAuths: Array<WorkspaceProjectAuthToken> =
       await WorkspaceProjectAuthTokenService.getProjectAuths({
@@ -114,7 +158,7 @@ export class Service extends DatabaseService<Model> {
       const authToken: string = projectAuth.authToken;
       const workspaceType: WorkspaceType = projectAuth.workspaceType;
 
-      const notificationRules: Array<Model> =
+      const notificationRules: Array<WorkspaceNotificationRule> =
         await this.getMatchingNotificationRules({
           projectId: data.projectId,
           workspaceType: workspaceType,
@@ -130,13 +174,11 @@ export class Service extends DatabaseService<Model> {
       }
 
       logger.debug("Creating channels based on rules");
-      const createdWorkspaceChannels: Array<WorkspaceChannel> =
+      const createdWorkspaceChannels: Array<NotificationRuleWorkspaceChannel> =
         await this.createChannelsBasedOnRules({
-          projectOrUserAuthTokenForWorkspasce: authToken,
+          projectOrUserAuthTokenForWorkspace: authToken,
           workspaceType: workspaceType,
-          notificationRules: notificationRules.map((rule: Model) => {
-            return rule.notificationRule as CreateChannelNotificationRule;
-          }),
+          notificationRules: notificationRules,
           channelNameSiffix: data.channelNameSiffix,
           notificationEventType: data.notificationRuleEventType,
         });
@@ -147,24 +189,20 @@ export class Service extends DatabaseService<Model> {
       logger.debug("Inviting users and teams to channels based on rules");
       await this.inviteUsersAndTeamsToChannelsBasedOnRules({
         projectId: data.projectId,
-        projectOrUserAuthTokenForWorkspasce: authToken,
+        projectAuth: projectAuth,
         workspaceType: workspaceType,
-        notificationRules: notificationRules.map((rule: Model) => {
-          return rule.notificationRule as CreateChannelNotificationRule;
-        }),
-        channelNames: createdWorkspaceChannels.map(
-          (channel: WorkspaceChannel) => {
-            return channel.name;
-          },
-        ),
+        notificationRules: notificationRules,
+        notificationChannels: createdWorkspaceChannels,
       });
 
       logger.debug("Getting existing channel names from notification rules");
       const existingChannelNames: Array<string> =
         this.getExistingChannelNamesFromNotificationRules({
-          notificationRules: notificationRules.map((rule: Model) => {
-            return rule.notificationRule as BaseNotificationRule;
-          }),
+          notificationRules: notificationRules.map(
+            (rule: WorkspaceNotificationRule) => {
+              return rule.notificationRule as BaseNotificationRule;
+            },
+          ),
         }) || [];
 
       logger.debug("Existing channel names:");
@@ -181,19 +219,6 @@ export class Service extends DatabaseService<Model> {
       logger.debug(existingChannelNames);
 
       logger.debug("Posting messages to workspace channels");
-      await this.postToWorkspaceChannels({
-        workspaceUserId: this.getBotUserIdFromprojectAuthToken({
-          projectAuthToken: projectAuth,
-          workspaceType: workspaceType,
-        }),
-        projectOrUserAuthTokenForWorkspasce: authToken,
-        workspaceType: workspaceType,
-        workspaceMessagePayload: {
-          _type: "WorkspaceMessagePayload",
-          channelNames: existingChannelNames,
-          messageBlocks: data.messageBlocks,
-        },
-      });
 
       logger.debug("Channels created:");
       logger.debug(createdWorkspaceChannels);
@@ -207,71 +232,344 @@ export class Service extends DatabaseService<Model> {
     };
   }
 
-  public async postToWorkspaceChannels(data: {
-    workspaceUserId: string;
-    projectOrUserAuthTokenForWorkspasce: string;
+  public async getNotificationRulesWhereOnCallIsTrue(data: {
+    projectId: ObjectID;
+    notificationFor: NotificationFor;
+    notificationRuleEventType: NotificationRuleEventType;
+  }): Promise<Array<WorkspaceNotificationRule>> {
+    const workspaceTypes: Array<WorkspaceType> = Service.getAllWorkspaceTypes();
+
+    const result: Array<WorkspaceNotificationRule> = [];
+
+    for (const workspaceType of workspaceTypes) {
+      // get matching notification rules
+      const notificationRules: Array<WorkspaceNotificationRule> =
+        await this.getMatchingNotificationRules({
+          projectId: data.projectId,
+          notificationFor: data.notificationFor,
+          workspaceType: workspaceType,
+          notificationRuleEventType: data.notificationRuleEventType,
+        });
+
+      const filteredNotificationRules: Array<WorkspaceNotificationRule> =
+        notificationRules.filter((rule: WorkspaceNotificationRule) => {
+          return (rule.notificationRule as IncidentNotificationRule)
+            .shouldAutomaticallyInviteOnCallUsersToNewChannel;
+        });
+
+      result.push(...filteredNotificationRules);
+    }
+
+    return result;
+  }
+
+  public async getNotificationRulesWhereInviteOwnersIsTrue(data: {
+    projectId: ObjectID;
+    notificationFor: NotificationFor;
+    notificationRuleEventType: NotificationRuleEventType;
+  }): Promise<Array<WorkspaceNotificationRule>> {
+    const workspaceTypes: Array<WorkspaceType> = Service.getAllWorkspaceTypes();
+
+    const result: Array<WorkspaceNotificationRule> = [];
+
+    for (const workspaceType of workspaceTypes) {
+      // get matching notification rules
+      const notificationRules: Array<WorkspaceNotificationRule> =
+        await this.getMatchingNotificationRules({
+          projectId: data.projectId,
+          notificationFor: data.notificationFor,
+          workspaceType: workspaceType,
+          notificationRuleEventType: data.notificationRuleEventType,
+        });
+
+      const filteredNotificationRules: Array<WorkspaceNotificationRule> =
+        notificationRules.filter((rule: WorkspaceNotificationRule) => {
+          return (rule.notificationRule as CreateChannelNotificationRule)
+            .shouldInviteOwnersToNewChannel;
+        });
+
+      result.push(...filteredNotificationRules);
+    }
+
+    return result;
+  }
+
+  public async inviteUsersAndTeamsToChannelsBasedOnRules(data: {
+    projectId: ObjectID;
+    projectAuth: WorkspaceProjectAuthToken;
     workspaceType: WorkspaceType;
-    workspaceMessagePayload: WorkspaceMessagePayload;
+    notificationRules: Array<WorkspaceNotificationRule>;
+    notificationChannels: Array<NotificationRuleWorkspaceChannel>;
   }): Promise<void> {
-    logger.debug("postToWorkspaceChannels called with data:");
+    logger.debug("inviteUsersAndTeamsToChannelsBasedOnRules called with data:");
     logger.debug(data);
 
-    await WorkspaceUtil.getWorkspaceTypeUtil(data.workspaceType).sendMessage({
-      userId: data.workspaceUserId,
-      workspaceMessagePayload: data.workspaceMessagePayload,
-      authToken: data.projectOrUserAuthTokenForWorkspasce,
+    const inviteUserPayloads: Array<{
+      notificationRuleId: string;
+      userIds: Array<ObjectID>;
+    }> = await this.getUsersIdsToInviteToChannel({
+      notificationRules: data.notificationRules,
     });
 
-    logger.debug("Message posted to workspace channels successfully");
+    logger.debug("User IDs to invite by Workspace Notification Rule ID:");
+    logger.debug(inviteUserPayloads);
+
+    for (const inviteUserPayload of inviteUserPayloads) {
+      const userIds: Array<ObjectID> = inviteUserPayload.userIds;
+      const workspaceUserIds: Array<string> = [];
+
+      for (const userId of userIds) {
+        const workspaceUserId: string | null =
+          await this.getWorkspaceUserIdFromOneUptimeUserId({
+            projectId: data.projectId,
+            workspaceType: data.workspaceType,
+            oneuptimeUserId: userId,
+          });
+
+        if (workspaceUserId) {
+          workspaceUserIds.push(workspaceUserId);
+        } else {
+          try {
+            // send a message to channel that user cannot be invited because the account is not connected to workspace.
+
+            const channelIds: Array<string> =
+              data.notificationChannels
+                ?.filter((channel: NotificationRuleWorkspaceChannel) => {
+                  return (
+                    channel.notificationRuleId ===
+                    inviteUserPayload.notificationRuleId
+                  );
+                })
+                ?.map((channel: NotificationRuleWorkspaceChannel) => {
+                  return channel.id as string;
+                }) || [];
+
+            logger.debug("Channel IDs to send message to:");
+            logger.debug(channelIds);
+
+            await WorkspaceUtil.getWorkspaceTypeUtil(
+              data.workspaceType,
+            ).sendMessage({
+              userId: data.projectAuth.workspaceProjectId!,
+              authToken: data.projectAuth.authToken!,
+              workspaceMessagePayload: {
+                _type: "WorkspaceMessagePayload",
+                channelNames: [],
+
+                channelIds: channelIds,
+                workspaceType: data.workspaceType,
+                messageBlocks: [
+                  {
+                    _type: "WorkspacePayloadMarkdown",
+                    text: `${await UserService.getUserMarkdownString({
+                      userId: userId,
+                      projectId: data.projectId,
+                    })} cannot be invited to the channel because the account is not connected to ${data.workspaceType}. Please go to User Settings > ${data.workspaceType} on OneUptime Dashboard and connect the account.`,
+                  } as WorkspacePayloadMarkdown,
+                ],
+              },
+            });
+          } catch (e) {
+            logger.error("Error in sending message to channel");
+            logger.error(e);
+          }
+        }
+
+        logger.debug("Workspace User IDs to invite:");
+        logger.debug(workspaceUserIds);
+
+        await WorkspaceUtil.getWorkspaceTypeUtil(
+          data.workspaceType,
+        ).inviteUsersToChannels({
+          authToken: data.projectAuth.authToken!,
+          workspaceChannelInvitationPayload: {
+            channelNames: data.notificationChannels
+              .filter((channel: NotificationRuleWorkspaceChannel) => {
+                return (
+                  channel.notificationRuleId ===
+                  inviteUserPayload.notificationRuleId
+                );
+              })
+              .map((channel: NotificationRuleWorkspaceChannel) => {
+                return channel.name;
+              }),
+            workspaceUserIds: workspaceUserIds,
+          },
+        });
+      }
+    }
+
+    logger.debug("Users invited to channels successfully");
   }
 
-  public async inviteUsersAndTeamsToChannelsBasedOnRules(data: {
+  public async inviteUsersBasedOnRulesAndWorkspaceChannels(data: {
+    workspaceChannels: Array<NotificationRuleWorkspaceChannel>;
     projectId: ObjectID;
-    projectOrUserAuthTokenForWorkspasce: string;
-    workspaceType: WorkspaceType;
-    notificationRules: Array<CreateChannelNotificationRule>;
-    channelNames: Array<string>;
+    notificationRules: Array<WorkspaceNotificationRule>;
+    userIds: Array<ObjectID>;
   }): Promise<void> {
-    logger.debug("inviteUsersAndTeamsToChannelsBasedOnRules called with data:");
+    logger.debug(
+      "inviteUsersBasedOnRulesAndWorkspaceChannels called with data:",
+    );
     logger.debug(data);
+    const userIds: Array<ObjectID> = data.userIds;
 
-    const inviteUserIds: Array<ObjectID> =
-      await this.getUsersIdsToInviteToChannel({
-        notificationRules: data.notificationRules,
-      });
+    logger.debug("Users:");
+    logger.debug(userIds);
 
-    logger.debug("User IDs to invite:");
-    logger.debug(inviteUserIds);
+    // get all Workspaces.
+    const workspaceTypes: Array<WorkspaceType> = Service.getAllWorkspaceTypes();
 
-    const workspaceUserIds: Array<string> = [];
+    for (const workspaceType of workspaceTypes) {
+      // filter rules by workspaceType.
 
-    for (const userId of inviteUserIds) {
-      const workspaceUserId: string | null =
-        await this.getWorkspaceUserIdFromOneUptimeUserId({
-          projectId: data.projectId,
-          workspaceType: data.workspaceType,
-          oneuptimeUserId: userId,
+      const notificationRules: Array<WorkspaceNotificationRule> =
+        data.notificationRules.filter((rule: WorkspaceNotificationRule) => {
+          return rule.workspaceType === workspaceType;
+        });
+
+      logger.debug("Notification rules for workspace type:");
+      logger.debug(notificationRules);
+
+      const channelsToInviteToBasedOnRule: Array<NotificationRuleWorkspaceChannel> =
+        data.workspaceChannels.filter(
+          (channel: NotificationRuleWorkspaceChannel) => {
+            return notificationRules.find((rule: WorkspaceNotificationRule) => {
+              return rule.id?.toString() === channel.notificationRuleId;
+            });
+          },
+        );
+
+      logger.debug("Channels to invite to based on rule:");
+      logger.debug(channelsToInviteToBasedOnRule);
+
+      if (channelsToInviteToBasedOnRule.length === 0) {
+        logger.debug("No channels to invite to based on rule.");
+        continue;
+      }
+
+      // get auth token for workspace.
+
+      const projectAuth: WorkspaceProjectAuthToken | null =
+        await WorkspaceProjectAuthTokenService.findOneBy({
+          query: {
+            projectId: data.projectId,
+            workspaceType: workspaceType,
+          },
+          select: {
+            authToken: true,
+          },
+          props: {
+            isRoot: true,
+          },
         });
 
-      if (workspaceUserId) {
-        workspaceUserIds.push(workspaceUserId);
+      if (!projectAuth) {
+        logger.debug("No project auth found for workspace type");
+        continue;
       }
+
+      // inivte users to channels.
+
+      const workspaceUserIds: Array<string> = [];
+
+      for (const userId of userIds) {
+        const workspaceUserId: string | null =
+          await this.getWorkspaceUserIdFromOneUptimeUserId({
+            projectId: data.projectId,
+            workspaceType: workspaceType,
+            oneuptimeUserId: userId,
+          });
+
+        if (workspaceUserId) {
+          workspaceUserIds.push(workspaceUserId);
+        } else {
+          try {
+            // send a message to channel that user cannot be invited because the account is not connected to workspace.
+
+            const channelIds: Array<string> = channelsToInviteToBasedOnRule.map(
+              (channel: NotificationRuleWorkspaceChannel) => {
+                return channel.id as string;
+              },
+            );
+
+            logger.debug("Channel IDs to send message to:");
+            logger.debug(channelIds);
+
+            await WorkspaceUtil.getWorkspaceTypeUtil(workspaceType).sendMessage(
+              {
+                userId: projectAuth.workspaceProjectId!,
+                authToken: projectAuth.authToken!,
+                workspaceMessagePayload: {
+                  _type: "WorkspaceMessagePayload",
+                  channelNames: [],
+
+                  channelIds: channelIds,
+                  workspaceType: workspaceType,
+                  messageBlocks: [
+                    {
+                      _type: "WorkspacePayloadMarkdown",
+                      text: `${await UserService.getUserMarkdownString({
+                        userId: userId,
+                        projectId: data.projectId,
+                      })} cannot be invited to the channel because the account is not connected to ${workspaceType}. Please go to User Settings > ${workspaceType} on OneUptime Dashboard and connect the account.`,
+                    } as WorkspacePayloadMarkdown,
+                  ],
+                },
+              },
+            );
+          } catch (e) {
+            logger.error("Error in sending message to channel");
+            logger.error(e);
+          }
+        }
+      }
+
+      logger.debug("Workspace User IDs to invite:");
+      logger.debug(workspaceUserIds);
+
+      const channelNames: Array<string> = channelsToInviteToBasedOnRule.map(
+        (channel: NotificationRuleWorkspaceChannel) => {
+          return channel.name;
+        },
+      );
+
+      logger.debug("Channel names to invite to:");
+      logger.debug(channelNames);
+
+      await WorkspaceUtil.getWorkspaceTypeUtil(
+        workspaceType,
+      ).inviteUsersToChannels({
+        authToken: projectAuth.authToken!,
+        workspaceChannelInvitationPayload: {
+          channelNames: channelNames,
+          workspaceUserIds: workspaceUserIds,
+        },
+      });
     }
+  }
 
-    logger.debug("Workspace User IDs to invite:");
-    logger.debug(workspaceUserIds);
-
-    await WorkspaceUtil.getWorkspaceTypeUtil(
-      data.workspaceType,
-    ).inviteUsersToChannels({
-      authToken: data.projectOrUserAuthTokenForWorkspasce,
-      workspaceChannelInvitationPayload: {
-        channelNames: data.channelNames,
-        workspaceUserIds: workspaceUserIds,
-      },
-    });
+  public async inviteTeamsBasedOnRulesAndWorkspaceChannels(data: {
+    workspaceChannels: Array<NotificationRuleWorkspaceChannel>;
+    projectId: ObjectID;
+    notificationRules: Array<WorkspaceNotificationRule>;
+    teamIds: Array<ObjectID>;
+  }): Promise<void> {
+    const usersInTeam: Array<User> = await TeamMemberService.getUsersInTeams(
+      data.teamIds,
+    );
 
-    logger.debug("Users invited to channels successfully");
+    logger.debug("Users in teams:");
+    logger.debug(usersInTeam);
+
+    return this.inviteUsersBasedOnRulesAndWorkspaceChannels({
+      workspaceChannels: data.workspaceChannels,
+      projectId: data.projectId,
+      notificationRules: data.notificationRules,
+      userIds: usersInTeam.map((user: User) => {
+        return user.id!;
+      }),
+    });
   }
 
   public async getWorkspaceUserIdFromOneUptimeUserId(data: {
@@ -309,55 +607,69 @@ export class Service extends DatabaseService<Model> {
   }
 
   public async createChannelsBasedOnRules(data: {
-    projectOrUserAuthTokenForWorkspasce: string;
+    projectOrUserAuthTokenForWorkspace: string;
     workspaceType: WorkspaceType;
-    notificationRules: Array<CreateChannelNotificationRule>;
+    notificationRules: Array<WorkspaceNotificationRule>;
     channelNameSiffix: string;
     notificationEventType: NotificationRuleEventType;
-  }): Promise<Array<WorkspaceChannel>> {
+  }): Promise<Array<NotificationRuleWorkspaceChannel>> {
     logger.debug("createChannelsBasedOnRules called with data:");
     logger.debug(data);
 
-    const createdWorkspaceChannels: Array<WorkspaceChannel> = [];
+    const createdWorkspaceChannels: Array<NotificationRuleWorkspaceChannel> =
+      [];
     const createdChannelNames: Array<string> = [];
 
-    const newChannelNames: Array<string> =
-      this.getNewChannelNamesFromNotificationRules({
-        notificationRules: data.notificationRules,
-        channelNameSiffix: data.channelNameSiffix,
-        notificationEventType: data.notificationEventType,
-      });
+    const notificationChannels: Array<{
+      channelName: string;
+      notificationRuleId: string;
+    }> = this.getnotificationChannelssFromNotificationRules({
+      notificationRules: data.notificationRules,
+      channelNameSiffix: data.channelNameSiffix,
+      notificationEventType: data.notificationEventType,
+    });
 
     logger.debug("New channel names to be created:");
-    logger.debug(newChannelNames);
+    logger.debug(notificationChannels);
 
-    if (!newChannelNames || newChannelNames.length === 0) {
+    if (!notificationChannels || notificationChannels.length === 0) {
       logger.debug("No new channel names found. Returning empty array.");
       return [];
     }
 
-    for (const newChannelName of newChannelNames) {
-      if (createdChannelNames.includes(newChannelName)) {
+    for (const notificationChannel of notificationChannels) {
+      if (
+        createdChannelNames.filter((name: string) => {
+          return name === notificationChannel.channelName;
+        }).length > 0
+      ) {
         logger.debug(
-          `Channel name ${newChannelName} already created. Skipping.`,
+          `Channel name ${notificationChannel.channelName} already created. Skipping.`,
         );
         continue;
       }
 
-      logger.debug(`Creating new channel with name: ${newChannelName}`);
+      logger.debug(
+        `Creating new channel with name: ${notificationChannel.channelName}`,
+      );
       const channel: WorkspaceChannel =
         await WorkspaceUtil.getWorkspaceTypeUtil(
           data.workspaceType,
         ).createChannel({
-          authToken: data.projectOrUserAuthTokenForWorkspasce,
-          channelName: newChannelName,
+          authToken: data.projectOrUserAuthTokenForWorkspace,
+          channelName: notificationChannel.channelName,
         });
 
+      const notificationWorkspaceChannel: NotificationRuleWorkspaceChannel = {
+        ...channel,
+        notificationRuleId: notificationChannel.notificationRuleId,
+      };
+
       logger.debug("Channel created:");
       logger.debug(channel);
 
       createdChannelNames.push(channel.name);
-      createdWorkspaceChannels.push(channel);
+      createdWorkspaceChannels.push(notificationWorkspaceChannel);
     }
 
     logger.debug("Returning created workspace channels:");
@@ -367,15 +679,25 @@ export class Service extends DatabaseService<Model> {
   }
 
   public async getUsersIdsToInviteToChannel(data: {
-    notificationRules: Array<CreateChannelNotificationRule>;
-  }): Promise<Array<ObjectID>> {
+    notificationRules: Array<WorkspaceNotificationRule>;
+  }): Promise<
+    Array<{
+      notificationRuleId: string;
+      userIds: Array<ObjectID>;
+    }>
+  > {
     logger.debug("getUsersIdsToInviteToChannel called with data:");
     logger.debug(data);
 
-    const inviteUserIds: Array<ObjectID> = [];
+    const result: Array<{
+      notificationRuleId: string;
+      userIds: Array<ObjectID>;
+    }> = [];
 
-    for (const notificationRule of data.notificationRules) {
-      const workspaceRules: CreateChannelNotificationRule = notificationRule;
+    for (const workspaceNotificationRule of data.notificationRules) {
+      const inviteUserIds: Array<ObjectID> = [];
+      const workspaceRules: CreateChannelNotificationRule =
+        workspaceNotificationRule.notificationRule as CreateChannelNotificationRule;
 
       if (workspaceRules.shouldCreateNewChannel) {
         if (
@@ -433,12 +755,19 @@ export class Service extends DatabaseService<Model> {
           }
         }
       }
+
+      if (inviteUserIds.length > 0) {
+        result.push({
+          notificationRuleId: workspaceNotificationRule.id!.toString(),
+          userIds: inviteUserIds,
+        });
+      }
     }
 
     logger.debug("Final list of user IDs to invite:");
-    logger.debug(inviteUserIds);
+    logger.debug(result);
 
-    return inviteUserIds;
+    return result;
   }
 
   public getExistingChannelNamesFromNotificationRules(data: {
@@ -480,42 +809,58 @@ export class Service extends DatabaseService<Model> {
     return channelNames;
   }
 
-  public getNewChannelNamesFromNotificationRules(data: {
+  public getnotificationChannelssFromNotificationRules(data: {
     notificationEventType: NotificationRuleEventType;
-    notificationRules: Array<CreateChannelNotificationRule>;
+    notificationRules: Array<WorkspaceNotificationRule>;
     channelNameSiffix: string;
-  }): Array<string> {
-    logger.debug("getNewChannelNamesFromNotificationRules called with data:");
+  }): Array<{
+    channelName: string;
+    notificationRuleId: string;
+  }> {
+    logger.debug(
+      "getnotificationChannelssFromNotificationRules called with data:",
+    );
     logger.debug(data);
 
-    const channelNames: Array<string> = [];
+    const channels: Array<{
+      channelName: string;
+      notificationRuleId: string;
+    }> = [];
 
     for (const notificationRule of data.notificationRules) {
-      const workspaceRules: CreateChannelNotificationRule = notificationRule;
+      const workspaceRules: CreateChannelNotificationRule =
+        notificationRule.notificationRule as CreateChannelNotificationRule;
 
       logger.debug("Processing notification rule:");
       logger.debug(workspaceRules);
 
-      if (
-        workspaceRules.shouldCreateNewChannel &&
-        workspaceRules.newChannelTemplateName
-      ) {
-        const newChannelName: string =
+      if (workspaceRules.shouldCreateNewChannel) {
+        const notificationChannels: string =
           workspaceRules.newChannelTemplateName ||
           `oneuptime-${data.notificationEventType.toLowerCase()}-`;
 
         logger.debug("New channel template name:");
-        logger.debug(newChannelName);
+        logger.debug(notificationChannels);
 
         // add suffix and then check if it is already added or not.
-        const channelName: string = newChannelName + data.channelNameSiffix;
+        const channelName: string =
+          notificationChannels + data.channelNameSiffix;
 
         logger.debug("Final channel name with suffix:");
         logger.debug(channelName);
 
-        if (!channelNames.includes(channelName)) {
+        if (
+          channels.filter(
+            (name: { channelName: string; notificationRuleId: string }) => {
+              return name.channelName === channelName;
+            },
+          ).length === 0
+        ) {
           // if channel name is not already added then add it.
-          channelNames.push(channelName);
+          channels.push({
+            channelName: channelName,
+            notificationRuleId: notificationRule.id!.toString() || "",
+          });
           logger.debug(`Channel name ${channelName} added to the list.`);
         } else {
           logger.debug(
@@ -526,34 +871,37 @@ export class Service extends DatabaseService<Model> {
     }
 
     logger.debug("Final list of new channel names:");
-    logger.debug(channelNames);
+    logger.debug(channels);
 
-    return channelNames;
+    return channels;
   }
 
   private async getNotificationRules(data: {
     projectId: ObjectID;
     workspaceType: WorkspaceType;
     notificationRuleEventType: NotificationRuleEventType;
-  }): Promise<Array<Model>> {
+  }): Promise<Array<WorkspaceNotificationRule>> {
     logger.debug("getNotificationRules called with data:");
     logger.debug(data);
 
-    const notificationRules: Array<Model> = await this.findBy({
-      query: {
-        projectId: data.projectId,
-        workspaceType: data.workspaceType,
-        eventType: data.notificationRuleEventType,
-      },
-      select: {
-        notificationRule: true,
-      },
-      props: {
-        isRoot: true,
-      },
-      skip: 0,
-      limit: LIMIT_PER_PROJECT,
-    });
+    const notificationRules: Array<WorkspaceNotificationRule> =
+      await this.findBy({
+        query: {
+          projectId: data.projectId,
+          workspaceType: data.workspaceType,
+          eventType: data.notificationRuleEventType,
+        },
+        select: {
+          notificationRule: true,
+          workspaceType: true,
+          eventType: true,
+        },
+        props: {
+          isRoot: true,
+        },
+        skip: 0,
+        limit: LIMIT_PER_PROJECT,
+      });
 
     logger.debug("Notification rules retrieved:");
     logger.debug(notificationRules);
@@ -869,12 +1217,16 @@ export class Service extends DatabaseService<Model> {
     workspaceType: WorkspaceType;
     notificationRuleEventType: NotificationRuleEventType;
     notificationFor: NotificationFor;
-  }): Promise<Array<Model>> {
-    const notificationRules: Array<Model> = await this.getNotificationRules({
-      projectId: data.projectId,
-      workspaceType: data.workspaceType,
-      notificationRuleEventType: data.notificationRuleEventType,
-    });
+  }): Promise<Array<WorkspaceNotificationRule>> {
+    const notificationRules: Array<WorkspaceNotificationRule> =
+      await this.getNotificationRules({
+        projectId: data.projectId,
+        workspaceType: data.workspaceType,
+        notificationRuleEventType: data.notificationRuleEventType,
+      });
+
+    logger.debug("Notification rules retrieved:");
+    logger.debug(notificationRules);
 
     const values: {
       [key in NotificationRuleConditionCheckOn]:
@@ -885,9 +1237,13 @@ export class Service extends DatabaseService<Model> {
       notificationFor: data.notificationFor,
     });
 
-    const matchingNotificationRules: Array<Model> = [];
+    logger.debug("Values based on notification for:");
+    logger.debug(values);
+
+    const matchingNotificationRules: Array<WorkspaceNotificationRule> = [];
 
     for (const notificationRule of notificationRules) {
+      logger.debug("Checking if rule matches:");
       if (
         WorkspaceNotificationRuleUtil.isRuleMatching({
           notificationRule:
@@ -895,7 +1251,10 @@ export class Service extends DatabaseService<Model> {
           values: values,
         })
       ) {
+        logger.debug("Rule matches. Adding to the list.");
         matchingNotificationRules.push(notificationRule);
+      } else {
+        logger.debug("Rule does not match. Skipping.");
       }
     }