@oneuptime/common 9.5.7 → 9.5.9

package/Server/Services/AlertService.ts

@@ -368,6 +368,9 @@ export class Service extends DatabaseService<Model> {
           projectId: createdItem.projectId,
           alertId: createdItem.id,
           alertNumber: createdItem.alertNumber!,
+          ...(createdItem.alertNumberWithPrefix
+            ? { alertNumberWithPrefix: createdItem.alertNumberWithPrefix }
+            : {}),
         });
 
       logger.debug("Alert created. Workspace result:");

package/Server/Services/IncidentEpisodeFeedService.ts

@@ -9,6 +9,9 @@ import DatabaseService from "./DatabaseService";
 import Model, {
   IncidentEpisodeFeedEventType,
 } from "../../Models/DatabaseModels/IncidentEpisodeFeed";
+import WorkspaceNotificationRuleService, {
+  MessageBlocksByWorkspaceType,
+} from "./WorkspaceNotificationRuleService";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 
 export class Service extends DatabaseService<Model> {
@@ -30,6 +33,13 @@ export class Service extends DatabaseService<Model> {
     displayColor?: Color | undefined;
     userId?: ObjectID | undefined;
     postedAt?: Date | undefined;
+    workspaceNotification?:
+      | {
+          notifyUserId?: ObjectID | undefined;
+          sendWorkspaceNotification: boolean;
+          appendMessageBlocks?: Array<MessageBlocksByWorkspaceType> | undefined;
+        }
+      | undefined;
   }): Promise<void> {
     try {
       if (!data.incidentEpisodeId) {
@@ -83,12 +93,52 @@ export class Service extends DatabaseService<Model> {
           isRoot: true,
         },
       });
+
+      try {
+        if (
+          data.workspaceNotification &&
+          data.workspaceNotification?.sendWorkspaceNotification
+        ) {
+          await this.sendWorkspaceNotification({
+            projectId: data.projectId,
+            incidentEpisodeId: data.incidentEpisodeId,
+            feedInfoInMarkdown: data.feedInfoInMarkdown,
+            workspaceNotification: data.workspaceNotification,
+          });
+        }
+      } catch (e) {
+        logger.error("Error in sending notification to slack and teams");
+        logger.error(e);
+      }
     } catch (error) {
       logger.error("IncidentEpisodeFeedService.createIncidentEpisodeFeedItem");
       logger.error(error);
       // we dont want to throw the error here, as this is a non-critical operation
     }
   }
+
+  @CaptureSpan()
+  public async sendWorkspaceNotification(data: {
+    projectId: ObjectID;
+    incidentEpisodeId: ObjectID;
+    feedInfoInMarkdown: string;
+    workspaceNotification: {
+      notifyUserId?: ObjectID | undefined;
+      sendWorkspaceNotification: boolean;
+      appendMessageBlocks?: Array<MessageBlocksByWorkspaceType> | undefined;
+    };
+  }): Promise<void> {
+    return await WorkspaceNotificationRuleService.sendWorkspaceMarkdownNotification(
+      {
+        projectId: data.projectId,
+        notificationFor: {
+          incidentEpisodeId: data.incidentEpisodeId,
+        },
+        feedInfoInMarkdown: data.feedInfoInMarkdown,
+        workspaceNotification: data.workspaceNotification,
+      },
+    );
+  }
 }
 
 export default new Service();

package/Server/Services/IncidentEpisodeInternalNoteService.ts

@@ -1,8 +1,16 @@
 import ObjectID from "../../Types/ObjectID";
 import DatabaseService from "./DatabaseService";
 import Model from "../../Models/DatabaseModels/IncidentEpisodeInternalNote";
+import { OnCreate, OnUpdate } from "../Types/Database/Hooks";
+import IncidentEpisodeFeedService from "./IncidentEpisodeFeedService";
+import { IncidentEpisodeFeedEventType } from "../../Models/DatabaseModels/IncidentEpisodeFeed";
+import { Blue500 } from "../../Types/BrandColors";
+import { LIMIT_PER_PROJECT } from "../../Types/Database/LimitMax";
+import IncidentEpisodeService from "./IncidentEpisodeService";
+import IncidentEpisode from "../../Models/DatabaseModels/IncidentEpisode";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import File from "../../Models/DatabaseModels/File";
+import FileAttachmentMarkdownUtil from "../Utils/FileAttachmentMarkdownUtil";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
@@ -66,6 +74,161 @@ export class Service extends DatabaseService<Model> {
 
     return existingNote !== null;
   }
+
+  @CaptureSpan()
+  public override async onCreateSuccess(
+    _onCreate: OnCreate<Model>,
+    createdItem: Model,
+  ): Promise<Model> {
+    const userId: ObjectID | null | undefined =
+      createdItem.createdByUserId || createdItem.createdByUser?.id;
+
+    const incidentEpisodeId: ObjectID = createdItem.incidentEpisodeId!;
+
+    const episodeNumberResult: {
+      number: number | null;
+      numberWithPrefix: string | null;
+    } = await IncidentEpisodeService.getEpisodeNumber({
+      episodeId: incidentEpisodeId,
+    });
+    const episodeNumberDisplay: string =
+      episodeNumberResult.numberWithPrefix || "#" + episodeNumberResult.number;
+
+    const attachmentsMarkdown: string = await this.getAttachmentsMarkdown(
+      createdItem.id!,
+      "/incident-episode-internal-note/attachment",
+    );
+
+    await IncidentEpisodeFeedService.createIncidentEpisodeFeedItem({
+      incidentEpisodeId: createdItem.incidentEpisodeId!,
+      projectId: createdItem.projectId!,
+      incidentEpisodeFeedEventType: IncidentEpisodeFeedEventType.PrivateNote,
+      displayColor: Blue500,
+      userId: userId || undefined,
+      feedInfoInMarkdown: `📄 posted **private note** for this [Episode ${episodeNumberDisplay}](${(await IncidentEpisodeService.getEpisodeLinkInDashboard(createdItem.projectId!, incidentEpisodeId)).toString()}):
+
+${(createdItem.note || "") + attachmentsMarkdown}
+          `,
+      workspaceNotification: {
+        sendWorkspaceNotification: true,
+        notifyUserId: userId || undefined,
+      },
+    });
+
+    return createdItem;
+  }
+
+  @CaptureSpan()
+  public override async onUpdateSuccess(
+    onUpdate: OnUpdate<Model>,
+    _updatedItemIds: Array<ObjectID>,
+  ): Promise<OnUpdate<Model>> {
+    if (onUpdate.updateBy.data.note) {
+      const updatedItems: Array<Model> = await this.findBy({
+        query: onUpdate.updateBy.query,
+        limit: LIMIT_PER_PROJECT,
+        skip: 0,
+        props: {
+          isRoot: true,
+        },
+        select: {
+          incidentEpisodeId: true,
+          incidentEpisode: {
+            projectId: true,
+            episodeNumber: true,
+            episodeNumberWithPrefix: true,
+          },
+          projectId: true,
+          note: true,
+          createdByUserId: true,
+          createdByUser: {
+            _id: true,
+          },
+        },
+      });
+
+      const userId: ObjectID | null | undefined =
+        onUpdate.updateBy.props.userId;
+
+      for (const updatedItem of updatedItems) {
+        const episode: IncidentEpisode = updatedItem.incidentEpisode!;
+
+        const attachmentsMarkdown: string = await this.getAttachmentsMarkdown(
+          updatedItem.id!,
+          "/incident-episode-internal-note/attachment",
+        );
+
+        await IncidentEpisodeFeedService.createIncidentEpisodeFeedItem({
+          incidentEpisodeId: updatedItem.incidentEpisodeId!,
+          projectId: updatedItem.projectId!,
+          incidentEpisodeFeedEventType:
+            IncidentEpisodeFeedEventType.PrivateNote,
+          displayColor: Blue500,
+          userId: userId || undefined,
+          feedInfoInMarkdown: `📄 updated **Private Note** for this [Episode ${episode.episodeNumberWithPrefix || "#" + episode.episodeNumber}](${(await IncidentEpisodeService.getEpisodeLinkInDashboard(episode.projectId!, episode.id!)).toString()})
+
+${(updatedItem.note || "") + attachmentsMarkdown}
+          `,
+          workspaceNotification: {
+            sendWorkspaceNotification: true,
+            notifyUserId: userId || undefined,
+          },
+        });
+      }
+    }
+    return onUpdate;
+  }
+
+  private async getAttachmentsMarkdown(
+    modelId: ObjectID,
+    attachmentApiPath: string,
+  ): Promise<string> {
+    if (!modelId) {
+      return "";
+    }
+
+    const noteWithAttachments: Model | null = await this.findOneById({
+      id: modelId,
+      select: {
+        attachments: {
+          _id: true,
+        },
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    if (!noteWithAttachments || !noteWithAttachments.attachments) {
+      return "";
+    }
+
+    const attachmentIds: Array<ObjectID> = noteWithAttachments.attachments
+      .map((file: File) => {
+        if (file.id) {
+          return file.id;
+        }
+
+        if (file._id) {
+          return new ObjectID(file._id);
+        }
+
+        return null;
+      })
+      .filter((id: ObjectID | null): id is ObjectID => {
+        return Boolean(id);
+      });
+
+    if (!attachmentIds.length) {
+      return "";
+    }
+
+    return await FileAttachmentMarkdownUtil.buildAttachmentMarkdown({
+      modelId,
+      attachmentIds,
+      attachmentApiPath,
+    });
+  }
 }
 
 export default new Service();

package/Server/Services/IncidentEpisodeMemberService.ts

@@ -144,6 +144,10 @@ export class Service extends DatabaseService<Model> {
       displayColor: Yellow500,
       feedInfoInMarkdown: `**Incident ${incident?.incidentNumberWithPrefix || "#" + (incident?.incidentNumber || "N/A")}** added to episode: ${incident?.title || "No title"}`,
       userId: createdItem.addedByUserId || undefined,
+      workspaceNotification: {
+        sendWorkspaceNotification: true,
+        notifyUserId: createdItem.addedByUserId || undefined,
+      },
     });
 
     // Create feed item on incident
@@ -242,6 +246,9 @@ export class Service extends DatabaseService<Model> {
                 IncidentEpisodeFeedEventType.IncidentRemoved,
               displayColor: Green500,
               feedInfoInMarkdown: `**Incident ${incident?.incidentNumberWithPrefix || "#" + (incident?.incidentNumber || "N/A")}** removed from episode: ${incident?.title || "No title"}`,
+              workspaceNotification: {
+                sendWorkspaceNotification: true,
+              },
             });
 
             // Create feed item on incident

package/Server/Services/IncidentEpisodeOwnerTeamService.ts

@@ -1,10 +1,199 @@
+import ObjectID from "../../Types/ObjectID";
+import { OnCreate, OnDelete } from "../Types/Database/Hooks";
 import DatabaseService from "./DatabaseService";
 import Model from "../../Models/DatabaseModels/IncidentEpisodeOwnerTeam";
+import IncidentEpisodeFeedService from "./IncidentEpisodeFeedService";
+import { IncidentEpisodeFeedEventType } from "../../Models/DatabaseModels/IncidentEpisodeFeed";
+import { Gray500, Red500 } from "../../Types/BrandColors";
+import TeamService from "./TeamService";
+import Team from "../../Models/DatabaseModels/Team";
+import DeleteBy from "../Types/Database/DeleteBy";
+import IncidentEpisodeService from "./IncidentEpisodeService";
+import IncidentEpisode from "../../Models/DatabaseModels/IncidentEpisode";
+import WorkspaceNotificationRuleService from "./WorkspaceNotificationRuleService";
+import NotificationRuleEventType from "../../Types/Workspace/NotificationRules/EventType";
+import WorkspaceNotificationRule from "../../Models/DatabaseModels/WorkspaceNotificationRule";
+import logger from "../Utils/Logger";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
     super(Model);
   }
+
+  @CaptureSpan()
+  protected override async onBeforeDelete(
+    deleteBy: DeleteBy<Model>,
+  ): Promise<OnDelete<Model>> {
+    const itemsToDelete: Model[] = await this.findBy({
+      query: deleteBy.query,
+      limit: deleteBy.limit,
+      skip: deleteBy.skip,
+      props: {
+        isRoot: true,
+      },
+      select: {
+        incidentEpisodeId: true,
+        projectId: true,
+        teamId: true,
+      },
+    });
+
+    return {
+      carryForward: {
+        itemsToDelete: itemsToDelete,
+      },
+      deleteBy: deleteBy,
+    };
+  }
+
+  @CaptureSpan()
+  protected override async onDeleteSuccess(
+    onDelete: OnDelete<Model>,
+    _itemIdsBeforeDelete: Array<ObjectID>,
+  ): Promise<OnDelete<Model>> {
+    const deleteByUserId: ObjectID | undefined =
+      onDelete.deleteBy.deletedByUser?.id || onDelete.deleteBy.props.userId;
+
+    const itemsToDelete: Model[] = onDelete.carryForward.itemsToDelete;
+
+    for (const item of itemsToDelete) {
+      const incidentEpisodeId: ObjectID | undefined = item.incidentEpisodeId;
+      const projectId: ObjectID | undefined = item.projectId;
+      const teamId: ObjectID | undefined = item.teamId;
+
+      if (incidentEpisodeId && teamId && projectId) {
+        const team: Team | null = await TeamService.findOneById({
+          id: teamId,
+          select: {
+            name: true,
+          },
+          props: {
+            isRoot: true,
+          },
+        });
+
+        const episodeNumberResult: {
+          number: number | null;
+          numberWithPrefix: string | null;
+        } = await IncidentEpisodeService.getEpisodeNumber({
+          episodeId: incidentEpisodeId,
+        });
+        const episodeNumberDisplay: string =
+          episodeNumberResult.numberWithPrefix ||
+          "#" + episodeNumberResult.number;
+
+        if (team && team.name) {
+          await IncidentEpisodeFeedService.createIncidentEpisodeFeedItem({
+            incidentEpisodeId: incidentEpisodeId,
+            projectId: projectId,
+            incidentEpisodeFeedEventType:
+              IncidentEpisodeFeedEventType.OwnerTeamRemoved,
+            displayColor: Red500,
+            feedInfoInMarkdown: `👨🏻‍👩🏻‍👦🏻 Removed team **${team.name}** from the [Episode ${episodeNumberDisplay}](${(await IncidentEpisodeService.getEpisodeLinkInDashboard(projectId!, incidentEpisodeId!)).toString()}) as the owner.`,
+            userId: deleteByUserId || undefined,
+            workspaceNotification: {
+              sendWorkspaceNotification: true,
+              notifyUserId: deleteByUserId || undefined,
+            },
+          });
+        }
+      }
+    }
+
+    return onDelete;
+  }
+
+  @CaptureSpan()
+  public override async onCreateSuccess(
+    onCreate: OnCreate<Model>,
+    createdItem: Model,
+  ): Promise<Model> {
+    const incidentEpisodeId: ObjectID | undefined =
+      createdItem.incidentEpisodeId;
+    const projectId: ObjectID | undefined = createdItem.projectId;
+    const teamId: ObjectID | undefined = createdItem.teamId;
+    const createdByUserId: ObjectID | undefined =
+      createdItem.createdByUserId || onCreate.createBy.props.userId;
+
+    if (incidentEpisodeId && teamId && projectId) {
+      const team: Team | null = await TeamService.findOneById({
+        id: teamId,
+        select: {
+          name: true,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+      if (team && team.name) {
+        const episodeNumberResult: {
+          number: number | null;
+          numberWithPrefix: string | null;
+        } = await IncidentEpisodeService.getEpisodeNumber({
+          episodeId: incidentEpisodeId,
+        });
+        const episodeNumberDisplay: string =
+          episodeNumberResult.numberWithPrefix ||
+          "#" + episodeNumberResult.number;
+
+        await IncidentEpisodeFeedService.createIncidentEpisodeFeedItem({
+          incidentEpisodeId: incidentEpisodeId,
+          projectId: projectId,
+          incidentEpisodeFeedEventType:
+            IncidentEpisodeFeedEventType.OwnerTeamAdded,
+          displayColor: Gray500,
+          feedInfoInMarkdown: `👨🏻‍👩🏻‍👦🏻 Added team **${team.name}** to the [Episode ${episodeNumberDisplay}](${(await IncidentEpisodeService.getEpisodeLinkInDashboard(projectId!, incidentEpisodeId!)).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: {
+              incidentEpisodeId: incidentEpisodeId,
+            },
+            notificationRuleEventType:
+              NotificationRuleEventType.IncidentEpisode,
+          },
+        );
+
+      // Fetch episode to get workspace channels
+      const episode: IncidentEpisode | null =
+        await IncidentEpisodeService.findOneById({
+          id: incidentEpisodeId,
+          select: {
+            postUpdatesToWorkspaceChannels: true,
+          },
+          props: {
+            isRoot: true,
+          },
+        });
+
+      if (episode) {
+        WorkspaceNotificationRuleService.inviteTeamsBasedOnRulesAndWorkspaceChannels(
+          {
+            notificationRules: notificationRules,
+            projectId: projectId,
+            workspaceChannels: episode.postUpdatesToWorkspaceChannels || [],
+            teamIds: [teamId],
+          },
+        ).catch((error: Error) => {
+          logger.error(error);
+        });
+      }
+    }
+
+    return createdItem;
+  }
 }
 
 export default new Service();

package/Server/Services/IncidentEpisodeOwnerUserService.ts

@@ -1,10 +1,193 @@
+import ObjectID from "../../Types/ObjectID";
 import DatabaseService from "./DatabaseService";
 import Model from "../../Models/DatabaseModels/IncidentEpisodeOwnerUser";
+import IncidentEpisodeFeedService from "./IncidentEpisodeFeedService";
+import { IncidentEpisodeFeedEventType } from "../../Models/DatabaseModels/IncidentEpisodeFeed";
+import { Gray500, Red500 } from "../../Types/BrandColors";
+import User from "../../Models/DatabaseModels/User";
+import UserService from "./UserService";
+import { OnCreate, OnDelete } from "../Types/Database/Hooks";
+import DeleteBy from "../Types/Database/DeleteBy";
+import IncidentEpisodeService from "./IncidentEpisodeService";
+import IncidentEpisode from "../../Models/DatabaseModels/IncidentEpisode";
+import WorkspaceNotificationRuleService from "./WorkspaceNotificationRuleService";
+import NotificationRuleEventType from "../../Types/Workspace/NotificationRules/EventType";
+import WorkspaceNotificationRule from "../../Models/DatabaseModels/WorkspaceNotificationRule";
+import logger from "../Utils/Logger";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
     super(Model);
   }
+
+  @CaptureSpan()
+  protected override async onBeforeDelete(
+    deleteBy: DeleteBy<Model>,
+  ): Promise<OnDelete<Model>> {
+    const itemsToDelete: Model[] = await this.findBy({
+      query: deleteBy.query,
+      limit: deleteBy.limit,
+      skip: deleteBy.skip,
+      props: {
+        isRoot: true,
+      },
+      select: {
+        incidentEpisodeId: true,
+        projectId: true,
+        userId: true,
+      },
+    });
+
+    return {
+      carryForward: {
+        itemsToDelete: itemsToDelete,
+      },
+      deleteBy: deleteBy,
+    };
+  }
+
+  @CaptureSpan()
+  protected override async onDeleteSuccess(
+    onDelete: OnDelete<Model>,
+    _itemIdsBeforeDelete: Array<ObjectID>,
+  ): Promise<OnDelete<Model>> {
+    const deleteByUserId: ObjectID | undefined =
+      onDelete.deleteBy.deletedByUser?.id || onDelete.deleteBy.props.userId;
+
+    const itemsToDelete: Model[] = onDelete.carryForward.itemsToDelete;
+
+    for (const item of itemsToDelete) {
+      const incidentEpisodeId: ObjectID | undefined = item.incidentEpisodeId;
+      const projectId: ObjectID | undefined = item.projectId;
+      const userId: ObjectID | undefined = item.userId;
+
+      if (incidentEpisodeId && userId && projectId) {
+        const user: User | null = await UserService.findOneById({
+          id: userId,
+          select: {
+            name: true,
+            email: true,
+          },
+          props: {
+            isRoot: true,
+          },
+        });
+
+        const episodeNumberResult: {
+          number: number | null;
+          numberWithPrefix: string | null;
+        } = await IncidentEpisodeService.getEpisodeNumber({
+          episodeId: incidentEpisodeId,
+        });
+        const episodeNumberDisplay: string =
+          episodeNumberResult.numberWithPrefix ||
+          "#" + episodeNumberResult.number;
+
+        if (user && user.name) {
+          await IncidentEpisodeFeedService.createIncidentEpisodeFeedItem({
+            incidentEpisodeId: incidentEpisodeId,
+            projectId: projectId,
+            incidentEpisodeFeedEventType:
+              IncidentEpisodeFeedEventType.OwnerUserRemoved,
+            displayColor: Red500,
+            feedInfoInMarkdown: `👨🏻‍💻 Removed **${user.name.toString()}** (${user.email?.toString()}) from the [Episode ${episodeNumberDisplay}](${(await IncidentEpisodeService.getEpisodeLinkInDashboard(projectId!, incidentEpisodeId!)).toString()}) as the owner.`,
+            userId: deleteByUserId || undefined,
+            workspaceNotification: {
+              sendWorkspaceNotification: true,
+              notifyUserId: userId || undefined,
+            },
+          });
+        }
+      }
+    }
+
+    return onDelete;
+  }
+
+  @CaptureSpan()
+  public override async onCreateSuccess(
+    onCreate: OnCreate<Model>,
+    createdItem: Model,
+  ): Promise<Model> {
+    const incidentEpisodeId: ObjectID | undefined =
+      createdItem.incidentEpisodeId;
+    const projectId: ObjectID | undefined = createdItem.projectId;
+    const userId: ObjectID | undefined = createdItem.userId;
+    const createdByUserId: ObjectID | undefined =
+      createdItem.createdByUserId || onCreate.createBy.props.userId;
+
+    if (incidentEpisodeId && userId && projectId) {
+      const episodeNumberResult: {
+        number: number | null;
+        numberWithPrefix: string | null;
+      } = await IncidentEpisodeService.getEpisodeNumber({
+        episodeId: incidentEpisodeId,
+      });
+      const episodeNumberDisplay: string =
+        episodeNumberResult.numberWithPrefix ||
+        "#" + episodeNumberResult.number;
+
+      await IncidentEpisodeFeedService.createIncidentEpisodeFeedItem({
+        incidentEpisodeId: incidentEpisodeId,
+        projectId: projectId,
+        incidentEpisodeFeedEventType:
+          IncidentEpisodeFeedEventType.OwnerUserAdded,
+        displayColor: Gray500,
+        feedInfoInMarkdown: `👨🏻‍💻 Added **${await UserService.getUserMarkdownString(
+          {
+            userId: userId,
+            projectId: projectId,
+          },
+        )}** to the [Episode ${episodeNumberDisplay}](${(await IncidentEpisodeService.getEpisodeLinkInDashboard(projectId!, incidentEpisodeId!)).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: {
+              incidentEpisodeId: incidentEpisodeId,
+            },
+            notificationRuleEventType:
+              NotificationRuleEventType.IncidentEpisode,
+          },
+        );
+
+      // Fetch episode to get workspace channels
+      const episode: IncidentEpisode | null =
+        await IncidentEpisodeService.findOneById({
+          id: incidentEpisodeId,
+          select: {
+            postUpdatesToWorkspaceChannels: true,
+          },
+          props: {
+            isRoot: true,
+          },
+        });
+
+      if (episode) {
+        WorkspaceNotificationRuleService.inviteUsersBasedOnRulesAndWorkspaceChannels(
+          {
+            notificationRules: notificationRules,
+            projectId: projectId,
+            workspaceChannels: episode.postUpdatesToWorkspaceChannels || [],
+            userIds: [userId],
+          },
+        ).catch((error: Error) => {
+          logger.error(error);
+        });
+      }
+    }
+
+    return createdItem;
+  }
 }
 
 export default new Service();

package/Server/Services/IncidentEpisodePublicNoteService.ts

@@ -140,6 +140,10 @@ export class Service extends DatabaseService<Model> {
 
 ${(createdItem.note || "") + attachmentsMarkdown}
           `,
+      workspaceNotification: {
+        sendWorkspaceNotification: true,
+        notifyUserId: userId || undefined,
+      },
     });
 
     return createdItem;
@@ -196,6 +200,10 @@ ${(createdItem.note || "") + attachmentsMarkdown}
 
 ${(updatedItem.note || "") + attachmentsMarkdown}
                   `,
+          workspaceNotification: {
+            sendWorkspaceNotification: true,
+            notifyUserId: userId || undefined,
+          },
         });
       }
     }