@oneuptime/common 9.4.13 → 9.5.0

package/Server/Services/IncidentEpisodeRoleMemberService.ts

@@ -0,0 +1,227 @@
+import ObjectID from "../../Types/ObjectID";
+import DatabaseService from "./DatabaseService";
+import Model from "../../Models/DatabaseModels/IncidentEpisodeRoleMember";
+import IncidentMember from "../../Models/DatabaseModels/IncidentMember";
+import IncidentMemberService from "./IncidentMemberService";
+import IncidentEpisodeMember from "../../Models/DatabaseModels/IncidentEpisodeMember";
+import IncidentEpisodeMemberService from "./IncidentEpisodeMemberService";
+import { OnCreate, OnDelete } from "../Types/Database/Hooks";
+import DeleteBy from "../Types/Database/DeleteBy";
+import logger from "../Utils/Logger";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import { LIMIT_PER_PROJECT } from "../../Types/Database/LimitMax";
+
+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,
+        incidentRoleId: true,
+      },
+    });
+
+    return {
+      carryForward: {
+        itemsToDelete: itemsToDelete,
+      },
+      deleteBy: deleteBy,
+    };
+  }
+
+  @CaptureSpan()
+  protected override async onDeleteSuccess(
+    onDelete: OnDelete<Model>,
+    _itemIdsBeforeDelete: Array<ObjectID>,
+  ): Promise<OnDelete<Model>> {
+    const itemsToDelete: Model[] = onDelete.carryForward.itemsToDelete;
+
+    // Remove the role assignment from all incidents in the episode
+    for (const item of itemsToDelete) {
+      await this.removeRoleFromIncidentsInEpisode({
+        incidentEpisodeId: item.incidentEpisodeId!,
+        userId: item.userId!,
+        incidentRoleId: item.incidentRoleId!,
+        projectId: item.projectId!,
+      });
+    }
+
+    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 incidentRoleId: ObjectID | undefined = createdItem.incidentRoleId;
+
+    if (incidentEpisodeId && userId && projectId && incidentRoleId) {
+      // Propagate role assignment to all incidents in the episode
+      await this.propagateRoleToIncidentsInEpisode({
+        incidentEpisodeId,
+        userId,
+        incidentRoleId,
+        projectId,
+      });
+    }
+
+    return createdItem;
+  }
+
+  @CaptureSpan()
+  private async propagateRoleToIncidentsInEpisode(data: {
+    incidentEpisodeId: ObjectID;
+    userId: ObjectID;
+    incidentRoleId: ObjectID;
+    projectId: ObjectID;
+  }): Promise<void> {
+    const { incidentEpisodeId, userId, incidentRoleId, projectId } = data;
+
+    try {
+      // Get all incidents in this episode
+      const episodeMembers: Array<IncidentEpisodeMember> =
+        await IncidentEpisodeMemberService.findBy({
+          query: {
+            incidentEpisodeId: incidentEpisodeId,
+            projectId: projectId,
+          },
+          select: {
+            incidentId: true,
+          },
+          skip: 0,
+          limit: LIMIT_PER_PROJECT,
+          props: {
+            isRoot: true,
+          },
+        });
+
+      // Add the role to each incident
+      for (const episodeMember of episodeMembers) {
+        if (!episodeMember.incidentId) {
+          continue;
+        }
+
+        // Check if the user already has this role on the incident
+        const existingMember: IncidentMember | null =
+          await IncidentMemberService.findOneBy({
+            query: {
+              incidentId: episodeMember.incidentId,
+              userId: userId,
+              incidentRoleId: incidentRoleId,
+              projectId: projectId,
+            },
+            select: {
+              _id: true,
+            },
+            props: {
+              isRoot: true,
+            },
+          });
+
+        if (existingMember) {
+          // User already has this role on the incident
+          continue;
+        }
+
+        // Create the incident member
+        const incidentMember: IncidentMember = new IncidentMember();
+        incidentMember.incidentId = episodeMember.incidentId;
+        incidentMember.userId = userId;
+        incidentMember.incidentRoleId = incidentRoleId;
+        incidentMember.projectId = projectId;
+
+        await IncidentMemberService.create({
+          data: incidentMember,
+          props: {
+            isRoot: true,
+          },
+        });
+
+        logger.debug(
+          `Propagated role ${incidentRoleId.toString()} to incident ${episodeMember.incidentId.toString()} for user ${userId.toString()}`,
+        );
+      }
+    } catch (error) {
+      logger.error(
+        `Failed to propagate role to incidents in episode: ${error}`,
+      );
+    }
+  }
+
+  @CaptureSpan()
+  private async removeRoleFromIncidentsInEpisode(data: {
+    incidentEpisodeId: ObjectID;
+    userId: ObjectID;
+    incidentRoleId: ObjectID;
+    projectId: ObjectID;
+  }): Promise<void> {
+    const { incidentEpisodeId, userId, incidentRoleId, projectId } = data;
+
+    try {
+      // Get all incidents in this episode
+      const episodeMembers: Array<IncidentEpisodeMember> =
+        await IncidentEpisodeMemberService.findBy({
+          query: {
+            incidentEpisodeId: incidentEpisodeId,
+            projectId: projectId,
+          },
+          select: {
+            incidentId: true,
+          },
+          skip: 0,
+          limit: LIMIT_PER_PROJECT,
+          props: {
+            isRoot: true,
+          },
+        });
+
+      // Remove the role from each incident
+      for (const episodeMember of episodeMembers) {
+        if (!episodeMember.incidentId) {
+          continue;
+        }
+
+        await IncidentMemberService.deleteBy({
+          query: {
+            incidentId: episodeMember.incidentId,
+            userId: userId,
+            incidentRoleId: incidentRoleId,
+            projectId: projectId,
+          },
+          limit: 1,
+          skip: 0,
+          props: {
+            isRoot: true,
+          },
+        });
+
+        logger.debug(
+          `Removed role ${incidentRoleId.toString()} from incident ${episodeMember.incidentId.toString()} for user ${userId.toString()}`,
+        );
+      }
+    } catch (error) {
+      logger.error(`Failed to remove role from incidents in episode: ${error}`);
+    }
+  }
+}
+
+export default new Service();

package/Server/Services/IncidentEpisodeService.ts

@@ -293,7 +293,7 @@ export class Service extends DatabaseService<Model> {
               {
                 triggeredByIncidentEpisodeId: createdItem.id!,
                 userNotificationEventType:
-                  UserNotificationEventType.IncidentCreated,
+                  UserNotificationEventType.IncidentEpisodeCreated,
               },
             );
           },

package/Server/Services/IncidentGroupingEngineService.ts

@@ -5,6 +5,9 @@ import IncidentEpisode from "../../Models/DatabaseModels/IncidentEpisode";
 import IncidentEpisodeMember, {
   IncidentEpisodeMemberAddedBy,
 } from "../../Models/DatabaseModels/IncidentEpisodeMember";
+import IncidentEpisodeOwnerUser from "../../Models/DatabaseModels/IncidentEpisodeOwnerUser";
+import IncidentEpisodeOwnerTeam from "../../Models/DatabaseModels/IncidentEpisodeOwnerTeam";
+import IncidentEpisodeRoleMember from "../../Models/DatabaseModels/IncidentEpisodeRoleMember";
 import Label from "../../Models/DatabaseModels/Label";
 import Monitor from "../../Models/DatabaseModels/Monitor";
 import IncidentSeverity from "../../Models/DatabaseModels/IncidentSeverity";
@@ -17,6 +20,9 @@ import QueryHelper from "../Types/Database/QueryHelper";
 import IncidentGroupingRuleService from "./IncidentGroupingRuleService";
 import IncidentEpisodeService from "./IncidentEpisodeService";
 import IncidentEpisodeMemberService from "./IncidentEpisodeMemberService";
+import IncidentEpisodeOwnerUserService from "./IncidentEpisodeOwnerUserService";
+import IncidentEpisodeOwnerTeamService from "./IncidentEpisodeOwnerTeamService";
+import IncidentEpisodeRoleMemberService from "./IncidentEpisodeRoleMemberService";
 import MonitorService from "./MonitorService";
 import ServiceMonitorService from "./ServiceMonitorService";
 import Semaphore, { SemaphoreMutex } from "../Infrastructure/Semaphore";
@@ -102,6 +108,20 @@ class IncidentGroupingEngineServiceClass {
             onCallDutyPolicies: {
               _id: true,
             },
+            // Episode configuration fields
+            episodeLabels: {
+              _id: true,
+            },
+            episodeOwnerUsers: {
+              _id: true,
+            },
+            episodeOwnerTeams: {
+              _id: true,
+            },
+            episodeMemberRoles: {
+              _id: true,
+            },
+            episodeMemberRoleAssignments: true,
           },
           limit: 100,
           skip: 0,
@@ -757,6 +777,11 @@ class IncidentGroupingEngineServiceClass {
       newEpisode.onCallDutyPolicies = rule.onCallDutyPolicies;
     }
 
+    // Copy episode labels from rule
+    if (rule.episodeLabels && rule.episodeLabels.length > 0) {
+      newEpisode.labels = rule.episodeLabels;
+    }
+
     try {
       const createdEpisode: IncidentEpisode =
         await IncidentEpisodeService.create({
@@ -766,6 +791,97 @@ class IncidentGroupingEngineServiceClass {
           },
         });
 
+      // Add episode owner users from rule
+      if (
+        rule.episodeOwnerUsers &&
+        rule.episodeOwnerUsers.length > 0 &&
+        createdEpisode.id
+      ) {
+        for (const user of rule.episodeOwnerUsers) {
+          if (!user.id) {
+            continue;
+          }
+          try {
+            const ownerUser: IncidentEpisodeOwnerUser =
+              new IncidentEpisodeOwnerUser();
+            ownerUser.projectId = incident.projectId!;
+            ownerUser.incidentEpisodeId = createdEpisode.id;
+            ownerUser.userId = user.id;
+            await IncidentEpisodeOwnerUserService.create({
+              data: ownerUser,
+              props: {
+                isRoot: true,
+              },
+            });
+          } catch (ownerError) {
+            logger.error(
+              `Error adding owner user ${user.id} to episode: ${ownerError}`,
+            );
+          }
+        }
+      }
+
+      // Add episode owner teams from rule
+      if (
+        rule.episodeOwnerTeams &&
+        rule.episodeOwnerTeams.length > 0 &&
+        createdEpisode.id
+      ) {
+        for (const team of rule.episodeOwnerTeams) {
+          if (!team.id) {
+            continue;
+          }
+          try {
+            const ownerTeam: IncidentEpisodeOwnerTeam =
+              new IncidentEpisodeOwnerTeam();
+            ownerTeam.projectId = incident.projectId!;
+            ownerTeam.incidentEpisodeId = createdEpisode.id;
+            ownerTeam.teamId = team.id;
+            await IncidentEpisodeOwnerTeamService.create({
+              data: ownerTeam,
+              props: {
+                isRoot: true,
+              },
+            });
+          } catch (ownerError) {
+            logger.error(
+              `Error adding owner team ${team.id} to episode: ${ownerError}`,
+            );
+          }
+        }
+      }
+
+      // Add episode member role assignments from rule
+      if (
+        rule.episodeMemberRoleAssignments &&
+        rule.episodeMemberRoleAssignments.length > 0 &&
+        createdEpisode.id
+      ) {
+        for (const assignment of rule.episodeMemberRoleAssignments) {
+          if (!assignment.userId || !assignment.incidentRoleId) {
+            continue;
+          }
+          try {
+            const roleMember: IncidentEpisodeRoleMember =
+              new IncidentEpisodeRoleMember();
+            roleMember.projectId = incident.projectId!;
+            roleMember.incidentEpisodeId = createdEpisode.id;
+            roleMember.userId = new ObjectID(assignment.userId);
+            roleMember.incidentRoleId = new ObjectID(assignment.incidentRoleId);
+            await IncidentEpisodeRoleMemberService.create({
+              data: roleMember,
+              props: {
+                isRoot: true,
+              },
+            });
+          } catch (memberError) {
+            logger.error(
+              `Error adding member role assignment to episode: ${memberError}`,
+            );
+          }
+        }
+      }
+
       // Add episode feed entry for episode creation
       if (createdEpisode.id) {
         const groupByParts: Array<string> = [];
@@ -832,17 +948,17 @@ class IncidentGroupingEngineServiceClass {
         incident.monitors.length > 0 &&
         incident.monitors[0]?.name
       ) {
-        return `Incident Episode: ${incident.monitors[0].name}`;
+        return incident.monitors[0].name;
       }
       if (incident.title) {
-        return `Incident Episode: ${incident.title.substring(0, 50)}`;
+        return incident.title.substring(0, 50);
       }
-      return "Incident Episode";
+      return "Untitled Episode";
     }
 
     return (
       this.replaceTemplatePlaceholders(incident, template, incidentCount) ||
-      "Incident Episode"
+      "Untitled Episode"
     );
   }
 

package/Server/Services/IncidentMemberService.ts

@@ -0,0 +1,251 @@
+import ObjectID from "../../Types/ObjectID";
+import DatabaseService from "./DatabaseService";
+import Model from "../../Models/DatabaseModels/IncidentMember";
+import IncidentFeedService from "./IncidentFeedService";
+import { IncidentFeedEventType } from "../../Models/DatabaseModels/IncidentFeed";
+import { Gray500, Red500 } from "../../Types/BrandColors";
+import User from "../../Models/DatabaseModels/User";
+import UserService from "./UserService";
+import { OnCreate, OnDelete } from "../Types/Database/Hooks";
+import CreateBy from "../Types/Database/CreateBy";
+import DeleteBy from "../Types/Database/DeleteBy";
+import IncidentService from "./IncidentService";
+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";
+import IncidentRole from "../../Models/DatabaseModels/IncidentRole";
+import IncidentRoleService from "./IncidentRoleService";
+import BadDataException from "../../Types/Exception/BadDataException";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+  }
+
+  @CaptureSpan()
+  protected override async onBeforeCreate(
+    createBy: CreateBy<Model>,
+  ): Promise<OnCreate<Model>> {
+    if (!createBy.data.incidentId) {
+      throw new BadDataException("incidentId is required");
+    }
+
+    if (!createBy.data.userId) {
+      throw new BadDataException("userId is required");
+    }
+
+    if (!createBy.data.incidentRoleId) {
+      throw new BadDataException("incidentRoleId is required");
+    }
+
+    // Check if this user is already assigned to this role for this incident
+    const existingMember: Model | null = await this.findOneBy({
+      query: {
+        incidentId: createBy.data.incidentId,
+        userId: createBy.data.userId,
+        incidentRoleId: createBy.data.incidentRoleId,
+      },
+      props: {
+        isRoot: true,
+      },
+      select: {
+        _id: true,
+      },
+    });
+
+    if (existingMember) {
+      throw new BadDataException(
+        "This user is already assigned to this role for this incident",
+      );
+    }
+
+    return { createBy, carryForward: null };
+  }
+
+  @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: {
+        incidentId: true,
+        projectId: true,
+        userId: true,
+        incidentRoleId: 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 incidentId: ObjectID | undefined = item.incidentId;
+      const projectId: ObjectID | undefined = item.projectId;
+      const userId: ObjectID | undefined = item.userId;
+      const incidentRoleId: ObjectID | undefined = item.incidentRoleId;
+
+      if (incidentId && userId && projectId) {
+        const user: User | null = await UserService.findOneById({
+          id: userId,
+          select: {
+            name: true,
+            email: true,
+          },
+          props: {
+            isRoot: true,
+          },
+        });
+
+        let roleName: string = "Member";
+        if (incidentRoleId) {
+          const role: IncidentRole | null =
+            await IncidentRoleService.findOneById({
+              id: incidentRoleId,
+              select: {
+                name: true,
+              },
+              props: {
+                isRoot: true,
+              },
+            });
+          if (role && role.name) {
+            roleName = role.name;
+          }
+        }
+
+        const incidentNumber: number | null =
+          await IncidentService.getIncidentNumber({
+            incidentId: incidentId,
+          });
+
+        if (user && user.name) {
+          await IncidentFeedService.createIncidentFeedItem({
+            incidentId: incidentId,
+            projectId: projectId,
+            incidentFeedEventType: IncidentFeedEventType.IncidentMemberRemoved,
+            displayColor: Red500,
+            feedInfoInMarkdown: `👤 Removed **${user.name.toString()}** (${user.email?.toString()}) as **${roleName}** from [Incident ${incidentNumber}](${(await IncidentService.getIncidentLinkInDashboard(projectId!, incidentId!)).toString()}).`,
+            userId: deleteByUserId || undefined,
+            workspaceNotification: {
+              sendWorkspaceNotification: true,
+              notifyUserId: userId || undefined,
+            },
+          });
+        }
+      }
+    }
+
+    return onDelete;
+  }
+
+  @CaptureSpan()
+  public override async onCreateSuccess(
+    onCreate: OnCreate<Model>,
+    createdItem: Model,
+  ): Promise<Model> {
+    const incidentId: ObjectID | undefined = createdItem.incidentId;
+    const projectId: ObjectID | undefined = createdItem.projectId;
+    const userId: ObjectID | undefined = createdItem.userId;
+    const incidentRoleId: ObjectID | undefined = createdItem.incidentRoleId;
+    const createdByUserId: ObjectID | undefined =
+      createdItem.createdByUserId || onCreate.createBy.props.userId;
+
+    if (incidentId && userId && projectId) {
+      let roleName: string = "Member";
+      if (incidentRoleId) {
+        const role: IncidentRole | null = await IncidentRoleService.findOneById(
+          {
+            id: incidentRoleId,
+            select: {
+              name: true,
+            },
+            props: {
+              isRoot: true,
+            },
+          },
+        );
+        if (role && role.name) {
+          roleName = role.name;
+        }
+      }
+
+      const incidentNumber: number | null =
+        await IncidentService.getIncidentNumber({
+          incidentId: incidentId,
+        });
+
+      if (userId) {
+        await IncidentFeedService.createIncidentFeedItem({
+          incidentId: incidentId,
+          projectId: projectId,
+          incidentFeedEventType: IncidentFeedEventType.IncidentMemberAdded,
+          displayColor: Gray500,
+          feedInfoInMarkdown: `👤 Added **${await UserService.getUserMarkdownString(
+            {
+              userId: userId,
+              projectId: projectId,
+            },
+          )}** as **${roleName}** to [Incident ${incidentNumber}](${(await IncidentService.getIncidentLinkInDashboard(projectId!, incidentId!)).toString()}).`,
+          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: {
+            incidentId: incidentId,
+          },
+          notificationRuleEventType: NotificationRuleEventType.Incident,
+        },
+      );
+
+    WorkspaceNotificationRuleService.inviteUsersBasedOnRulesAndWorkspaceChannels(
+      {
+        notificationRules: notificationRules,
+        projectId: projectId!,
+        workspaceChannels: await IncidentService.getWorkspaceChannelForIncident(
+          {
+            incidentId: incidentId!,
+          },
+        ),
+        userIds: [userId!],
+      },
+    ).catch((error: Error) => {
+      logger.error(error);
+    });
+
+    return createdItem;
+  }
+}
+export default new Service();