@oneuptime/common 9.5.8 → 9.5.9

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;

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();