@oneuptime/common 9.5.7 → 9.5.9

package/Server/Services/AlertEpisodeInternalNoteService.ts

@@ -1,8 +1,16 @@
 import ObjectID from "../../Types/ObjectID";
 import DatabaseService from "./DatabaseService";
 import Model from "../../Models/DatabaseModels/AlertEpisodeInternalNote";
+import { OnCreate, OnUpdate } from "../Types/Database/Hooks";
+import AlertEpisodeFeedService from "./AlertEpisodeFeedService";
+import { AlertEpisodeFeedEventType } from "../../Models/DatabaseModels/AlertEpisodeFeed";
+import { Blue500 } from "../../Types/BrandColors";
+import { LIMIT_PER_PROJECT } from "../../Types/Database/LimitMax";
+import AlertEpisodeService from "./AlertEpisodeService";
+import AlertEpisode from "../../Models/DatabaseModels/AlertEpisode";
 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,160 @@ 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 alertEpisodeId: ObjectID = createdItem.alertEpisodeId!;
+
+    const episodeNumberResult: {
+      number: number | null;
+      numberWithPrefix: string | null;
+    } = await AlertEpisodeService.getEpisodeNumber({
+      episodeId: alertEpisodeId,
+    });
+    const episodeNumberDisplay: string =
+      episodeNumberResult.numberWithPrefix || "#" + episodeNumberResult.number;
+
+    const attachmentsMarkdown: string = await this.getAttachmentsMarkdown(
+      createdItem.id!,
+      "/alert-episode-internal-note/attachment",
+    );
+
+    await AlertEpisodeFeedService.createAlertEpisodeFeedItem({
+      alertEpisodeId: createdItem.alertEpisodeId!,
+      projectId: createdItem.projectId!,
+      alertEpisodeFeedEventType: AlertEpisodeFeedEventType.PrivateNote,
+      displayColor: Blue500,
+      userId: userId || undefined,
+      feedInfoInMarkdown: `📄 posted **private note** for this [Episode ${episodeNumberDisplay}](${(await AlertEpisodeService.getEpisodeLinkInDashboard(createdItem.projectId!, alertEpisodeId)).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: {
+          alertEpisodeId: true,
+          alertEpisode: {
+            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: AlertEpisode = updatedItem.alertEpisode!;
+
+        const attachmentsMarkdown: string = await this.getAttachmentsMarkdown(
+          updatedItem.id!,
+          "/alert-episode-internal-note/attachment",
+        );
+
+        await AlertEpisodeFeedService.createAlertEpisodeFeedItem({
+          alertEpisodeId: updatedItem.alertEpisodeId!,
+          projectId: updatedItem.projectId!,
+          alertEpisodeFeedEventType: AlertEpisodeFeedEventType.PrivateNote,
+          displayColor: Blue500,
+          userId: userId || undefined,
+          feedInfoInMarkdown: `📄 updated **Private Note** for this [Episode ${episode.episodeNumberWithPrefix || "#" + episode.episodeNumber}](${(await AlertEpisodeService.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/AlertEpisodeMemberService.ts

@@ -139,6 +139,10 @@ export class Service extends DatabaseService<Model> {
       displayColor: Yellow500,
       feedInfoInMarkdown: `**Alert ${alert?.alertNumberWithPrefix || "#" + (alert?.alertNumber || "N/A")}** added to episode: ${alert?.title || "No title"}`,
       userId: createdItem.addedByUserId || undefined,
+      workspaceNotification: {
+        sendWorkspaceNotification: true,
+        notifyUserId: createdItem.addedByUserId || undefined,
+      },
     });
 
     // Create feed item on alert
@@ -235,6 +239,9 @@ export class Service extends DatabaseService<Model> {
               alertEpisodeFeedEventType: AlertEpisodeFeedEventType.AlertRemoved,
               displayColor: Green500,
               feedInfoInMarkdown: `**Alert #${alert?.alertNumber || "N/A"}** removed from episode: ${alert?.title || "No title"}`,
+              workspaceNotification: {
+                sendWorkspaceNotification: true,
+              },
             });
 
             // Create feed item on alert

package/Server/Services/AlertEpisodeOwnerTeamService.ts

@@ -1,10 +1,196 @@
+import ObjectID from "../../Types/ObjectID";
+import { OnCreate, OnDelete } from "../Types/Database/Hooks";
 import DatabaseService from "./DatabaseService";
 import Model from "../../Models/DatabaseModels/AlertEpisodeOwnerTeam";
+import AlertEpisodeFeedService from "./AlertEpisodeFeedService";
+import { AlertEpisodeFeedEventType } from "../../Models/DatabaseModels/AlertEpisodeFeed";
+import { Gray500, Red500 } from "../../Types/BrandColors";
+import TeamService from "./TeamService";
+import Team from "../../Models/DatabaseModels/Team";
+import DeleteBy from "../Types/Database/DeleteBy";
+import AlertEpisodeService from "./AlertEpisodeService";
+import AlertEpisode from "../../Models/DatabaseModels/AlertEpisode";
+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: {
+        alertEpisodeId: 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 alertEpisodeId: ObjectID | undefined = item.alertEpisodeId;
+      const projectId: ObjectID | undefined = item.projectId;
+      const teamId: ObjectID | undefined = item.teamId;
+
+      if (alertEpisodeId && 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 AlertEpisodeService.getEpisodeNumber({
+          episodeId: alertEpisodeId,
+        });
+        const episodeNumberDisplay: string =
+          episodeNumberResult.numberWithPrefix ||
+          "#" + episodeNumberResult.number;
+
+        if (team && team.name) {
+          await AlertEpisodeFeedService.createAlertEpisodeFeedItem({
+            alertEpisodeId: alertEpisodeId,
+            projectId: projectId,
+            alertEpisodeFeedEventType:
+              AlertEpisodeFeedEventType.OwnerTeamRemoved,
+            displayColor: Red500,
+            feedInfoInMarkdown: `👨🏻‍👩🏻‍👦🏻 Removed team **${team.name}** from the [Episode ${episodeNumberDisplay}](${(await AlertEpisodeService.getEpisodeLinkInDashboard(projectId!, alertEpisodeId!)).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 alertEpisodeId: ObjectID | undefined = createdItem.alertEpisodeId;
+    const projectId: ObjectID | undefined = createdItem.projectId;
+    const teamId: ObjectID | undefined = createdItem.teamId;
+    const createdByUserId: ObjectID | undefined =
+      createdItem.createdByUserId || onCreate.createBy.props.userId;
+
+    if (alertEpisodeId && 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 AlertEpisodeService.getEpisodeNumber({
+          episodeId: alertEpisodeId,
+        });
+        const episodeNumberDisplay: string =
+          episodeNumberResult.numberWithPrefix ||
+          "#" + episodeNumberResult.number;
+
+        await AlertEpisodeFeedService.createAlertEpisodeFeedItem({
+          alertEpisodeId: alertEpisodeId,
+          projectId: projectId,
+          alertEpisodeFeedEventType: AlertEpisodeFeedEventType.OwnerTeamAdded,
+          displayColor: Gray500,
+          feedInfoInMarkdown: `👨🏻‍👩🏻‍👦🏻 Added team **${team.name}** to the [Episode ${episodeNumberDisplay}](${(await AlertEpisodeService.getEpisodeLinkInDashboard(projectId!, alertEpisodeId!)).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: {
+              alertEpisodeId: alertEpisodeId,
+            },
+            notificationRuleEventType: NotificationRuleEventType.AlertEpisode,
+          },
+        );
+
+      // Fetch episode to get workspace channels
+      const episode: AlertEpisode | null =
+        await AlertEpisodeService.findOneById({
+          id: alertEpisodeId,
+          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/AlertEpisodeOwnerUserService.ts

@@ -1,10 +1,190 @@
+import ObjectID from "../../Types/ObjectID";
 import DatabaseService from "./DatabaseService";
 import Model from "../../Models/DatabaseModels/AlertEpisodeOwnerUser";
+import AlertEpisodeFeedService from "./AlertEpisodeFeedService";
+import { AlertEpisodeFeedEventType } from "../../Models/DatabaseModels/AlertEpisodeFeed";
+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 AlertEpisodeService from "./AlertEpisodeService";
+import AlertEpisode from "../../Models/DatabaseModels/AlertEpisode";
+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: {
+        alertEpisodeId: 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 alertEpisodeId: ObjectID | undefined = item.alertEpisodeId;
+      const projectId: ObjectID | undefined = item.projectId;
+      const userId: ObjectID | undefined = item.userId;
+
+      if (alertEpisodeId && 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 AlertEpisodeService.getEpisodeNumber({
+          episodeId: alertEpisodeId,
+        });
+        const episodeNumberDisplay: string =
+          episodeNumberResult.numberWithPrefix ||
+          "#" + episodeNumberResult.number;
+
+        if (user && user.name) {
+          await AlertEpisodeFeedService.createAlertEpisodeFeedItem({
+            alertEpisodeId: alertEpisodeId,
+            projectId: projectId,
+            alertEpisodeFeedEventType:
+              AlertEpisodeFeedEventType.OwnerUserRemoved,
+            displayColor: Red500,
+            feedInfoInMarkdown: `👨🏻‍💻 Removed **${user.name.toString()}** (${user.email?.toString()}) from the [Episode ${episodeNumberDisplay}](${(await AlertEpisodeService.getEpisodeLinkInDashboard(projectId!, alertEpisodeId!)).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 alertEpisodeId: ObjectID | undefined = createdItem.alertEpisodeId;
+    const projectId: ObjectID | undefined = createdItem.projectId;
+    const userId: ObjectID | undefined = createdItem.userId;
+    const createdByUserId: ObjectID | undefined =
+      createdItem.createdByUserId || onCreate.createBy.props.userId;
+
+    if (alertEpisodeId && userId && projectId) {
+      const episodeNumberResult: {
+        number: number | null;
+        numberWithPrefix: string | null;
+      } = await AlertEpisodeService.getEpisodeNumber({
+        episodeId: alertEpisodeId,
+      });
+      const episodeNumberDisplay: string =
+        episodeNumberResult.numberWithPrefix ||
+        "#" + episodeNumberResult.number;
+
+      await AlertEpisodeFeedService.createAlertEpisodeFeedItem({
+        alertEpisodeId: alertEpisodeId,
+        projectId: projectId,
+        alertEpisodeFeedEventType: AlertEpisodeFeedEventType.OwnerUserAdded,
+        displayColor: Gray500,
+        feedInfoInMarkdown: `👨🏻‍💻 Added **${await UserService.getUserMarkdownString(
+          {
+            userId: userId,
+            projectId: projectId,
+          },
+        )}** to the [Episode ${episodeNumberDisplay}](${(await AlertEpisodeService.getEpisodeLinkInDashboard(projectId!, alertEpisodeId!)).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: {
+              alertEpisodeId: alertEpisodeId,
+            },
+            notificationRuleEventType: NotificationRuleEventType.AlertEpisode,
+          },
+        );
+
+      // Fetch episode to get workspace channels
+      const episode: AlertEpisode | null =
+        await AlertEpisodeService.findOneById({
+          id: alertEpisodeId,
+          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/AlertEpisodeService.ts

@@ -38,6 +38,8 @@ import User from "../../Models/DatabaseModels/User";
 import { LIMIT_PER_PROJECT } from "../../Types/Database/LimitMax";
 import NotificationRuleWorkspaceChannel from "../../Types/Workspace/NotificationRules/NotificationRuleWorkspaceChannel";
 import WorkspaceType from "../../Types/Workspace/WorkspaceType";
+import AlertEpisodeWorkspaceMessages from "../Utils/Workspace/WorkspaceMessages/AlertEpisode";
+import { MessageBlocksByWorkspaceType } from "./WorkspaceNotificationRuleService";
 import Typeof from "../../Types/Typeof";
 import AlertService from "./AlertService";
 import OnCallDutyPolicyService from "./OnCallDutyPolicyService";
@@ -124,6 +126,17 @@ export class Service extends DatabaseService<Model> {
 
     // Create initial state timeline entry
     Promise.resolve()
+      .then(async () => {
+        try {
+          if (createdItem.projectId && createdItem.id) {
+            await this.handleEpisodeWorkspaceOperationsAsync(createdItem);
+          }
+        } catch (error) {
+          logger.error(
+            `Workspace operations failed in AlertEpisodeService.onCreateSuccess: ${error}`,
+          );
+        }
+      })
       .then(async () => {
         try {
           await this.changeEpisodeState({
@@ -170,6 +183,51 @@ export class Service extends DatabaseService<Model> {
     return createdItem;
   }
 
+  @CaptureSpan()
+  private async handleEpisodeWorkspaceOperationsAsync(
+    createdItem: Model,
+  ): Promise<void> {
+    try {
+      if (!createdItem.projectId || !createdItem.id) {
+        throw new BadDataException(
+          "projectId and id are required for workspace operations",
+        );
+      }
+
+      const workspaceResult: {
+        channelsCreated: Array<NotificationRuleWorkspaceChannel>;
+      } | null =
+        await AlertEpisodeWorkspaceMessages.createChannelsAndInviteUsersToChannels(
+          {
+            projectId: createdItem.projectId,
+            alertEpisodeId: createdItem.id,
+            episodeNumber: createdItem.episodeNumber || 0,
+            ...(createdItem.episodeNumberWithPrefix
+              ? {
+                  episodeNumberWithPrefix: createdItem.episodeNumberWithPrefix,
+                }
+              : {}),
+          },
+        );
+
+      if (workspaceResult && workspaceResult.channelsCreated?.length > 0) {
+        await this.updateOneById({
+          id: createdItem.id,
+          data: {
+            postUpdatesToWorkspaceChannels:
+              workspaceResult.channelsCreated || [],
+          },
+          props: {
+            isRoot: true,
+          },
+        });
+      }
+    } catch (error) {
+      logger.error(`Error in handleEpisodeWorkspaceOperationsAsync: ${error}`);
+      throw error;
+    }
+  }
+
   @CaptureSpan()
   private async createEpisodeCreatedFeed(episode: Model): Promise<void> {
     if (!episode.id || !episode.projectId) {
@@ -190,6 +248,12 @@ export class Service extends DatabaseService<Model> {
       feedInfoInMarkdown += `This episode was manually created.\n\n`;
     }
 
+    const episodeCreateMessageBlocks: Array<MessageBlocksByWorkspaceType> =
+      await AlertEpisodeWorkspaceMessages.getAlertEpisodeCreateMessageBlocks({
+        alertEpisodeId: episode.id,
+        projectId: episode.projectId,
+      });
+
     await AlertEpisodeFeedService.createAlertEpisodeFeedItem({
       alertEpisodeId: episode.id,
       projectId: episode.projectId,
@@ -197,6 +261,10 @@ export class Service extends DatabaseService<Model> {
       displayColor: Red500,
       feedInfoInMarkdown: feedInfoInMarkdown,
       userId: episode.createdByUserId || undefined,
+      workspaceNotification: {
+        appendMessageBlocks: episodeCreateMessageBlocks,
+        sendWorkspaceNotification: true,
+      },
     });
   }
 

package/Server/Services/AlertEpisodeStateTimelineService.ts

@@ -374,6 +374,11 @@ export class Service extends DatabaseService<AlertEpisodeStateTimeline> {
         ? `**Cause:** \n${createdItem.rootCause}`
         : undefined,
       userId: createdItem.createdByUserId || onCreate.createBy.props.userId,
+      workspaceNotification: {
+        sendWorkspaceNotification: true,
+        notifyUserId:
+          createdItem.createdByUserId || onCreate.createBy.props.userId,
+      },
     });
 
     return createdItem;