@oneuptime/common 8.0.5492 → 8.0.5496

package/Models/DatabaseModels/Incident.ts

@@ -926,6 +926,39 @@ export default class Incident extends BaseModel {
   })
   public rootCause?: string = undefined;
 
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.CreateProjectIncident,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadProjectIncident,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.EditProjectIncident,
+    ],
+  })
+  @TableColumn({
+    type: TableColumnType.Markdown,
+    required: false,
+    isDefaultValueColumn: false,
+    title: "Postmortem Note",
+    description: "Document the postmortem summary for this incident.",
+  })
+  @Column({
+    type: ColumnType.Markdown,
+    nullable: true,
+  })
+  public postmortemNote?: string = undefined;
+
   @ColumnAccessControl({
     create: [],
     read: [

package/Models/DatabaseModels/IncidentFeed.ts

@@ -33,6 +33,7 @@ export enum IncidentFeedEventType {
   IncidentUpdated = "IncidentUpdated",
   RootCause = "RootCause",
   RemediationNotes = "RemediationNotes",
+  PostmortemNote = "PostmortemNote",
   OwnerUserRemoved = "OwnerUserRemoved",
   OwnerTeamRemoved = "OwnerTeamRemoved",
   OnCallPolicy = "OnCallPolicy",

package/Models/DatabaseModels/IncidentPostmortemTemplate.ts

@@ -0,0 +1,353 @@
+import Project from "./Project";
+import User from "./User";
+import BaseModel from "./DatabaseBaseModel/DatabaseBaseModel";
+import Route from "../../Types/API/Route";
+import ColumnAccessControl from "../../Types/Database/AccessControl/ColumnAccessControl";
+import TableAccessControl from "../../Types/Database/AccessControl/TableAccessControl";
+import ColumnLength from "../../Types/Database/ColumnLength";
+import ColumnType from "../../Types/Database/ColumnType";
+import CrudApiEndpoint from "../../Types/Database/CrudApiEndpoint";
+import EnableDocumentation from "../../Types/Database/EnableDocumentation";
+import EnableWorkflow from "../../Types/Database/EnableWorkflow";
+import TableColumn from "../../Types/Database/TableColumn";
+import TableColumnType from "../../Types/Database/TableColumnType";
+import TableMetadata from "../../Types/Database/TableMetadata";
+import TenantColumn from "../../Types/Database/TenantColumn";
+import IconProp from "../../Types/Icon/IconProp";
+import ObjectID from "../../Types/ObjectID";
+import Permission from "../../Types/Permission";
+import { Column, Entity, Index, JoinColumn, ManyToOne } from "typeorm";
+import TableBillingAccessControl from "../../Types/Database/AccessControl/TableBillingAccessControl";
+import { PlanType } from "../../Types/Billing/SubscriptionPlan";
+
+@TableBillingAccessControl({
+  create: PlanType.Growth,
+  read: PlanType.Growth,
+  update: PlanType.Growth,
+  delete: PlanType.Growth,
+})
+@EnableDocumentation()
+@TenantColumn("projectId")
+@TableAccessControl({
+  create: [
+    Permission.ProjectOwner,
+    Permission.ProjectAdmin,
+    Permission.ProjectMember,
+    Permission.CreateIncidentNoteTemplate,
+  ],
+  read: [
+    Permission.ProjectOwner,
+    Permission.ProjectAdmin,
+    Permission.ProjectMember,
+    Permission.ReadIncidentNoteTemplate,
+  ],
+  delete: [
+    Permission.ProjectOwner,
+    Permission.ProjectAdmin,
+    Permission.ProjectMember,
+    Permission.DeleteIncidentNoteTemplate,
+  ],
+  update: [
+    Permission.ProjectOwner,
+    Permission.ProjectAdmin,
+    Permission.ProjectMember,
+    Permission.EditIncidentNoteTemplate,
+  ],
+})
+@CrudApiEndpoint(new Route("/incident-postmortem-template"))
+@Entity({
+  name: "IncidentPostmortemTemplate",
+})
+@EnableWorkflow({
+  create: true,
+  delete: true,
+  update: true,
+  read: true,
+})
+@TableMetadata({
+  tableName: "IncidentPostmortemTemplate",
+  singularName: "Incident Postmortem Template",
+  pluralName: "Incident Postmortem Templates",
+  icon: IconProp.Book,
+  tableDescription: "Manage postmortem templates for your incidents",
+})
+export default class IncidentPostmortemTemplate extends BaseModel {
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.CreateIncidentNoteTemplate,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadIncidentNoteTemplate,
+    ],
+    update: [],
+  })
+  @TableColumn({
+    manyToOneRelationColumn: "projectId",
+    type: TableColumnType.Entity,
+    modelType: Project,
+    title: "Project",
+    description: "Relation to Project Resource in which this object belongs",
+  })
+  @ManyToOne(
+    () => {
+      return Project;
+    },
+    {
+      eager: false,
+      nullable: true,
+      onDelete: "CASCADE",
+      orphanedRowAction: "nullify",
+    },
+  )
+  @JoinColumn({ name: "projectId" })
+  public project?: Project = undefined;
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.CreateIncidentNoteTemplate,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadIncidentNoteTemplate,
+    ],
+    update: [],
+  })
+  @Index()
+  @TableColumn({
+    type: TableColumnType.ObjectID,
+    required: true,
+    canReadOnRelationQuery: true,
+    title: "Project ID",
+    description: "ID of your OneUptime Project in which this object belongs",
+  })
+  @Column({
+    type: ColumnType.ObjectID,
+    nullable: false,
+    transformer: ObjectID.getDatabaseTransformer(),
+  })
+  public projectId?: ObjectID = undefined;
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.CreateIncidentNoteTemplate,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadIncidentNoteTemplate,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.EditIncidentNoteTemplate,
+    ],
+  })
+  @Index()
+  @TableColumn({
+    type: TableColumnType.Markdown,
+    title: "Postmortem Note",
+    description:
+      "Markdown template used when documenting an incident postmortem.",
+  })
+  @Column({
+    type: ColumnType.Markdown,
+    nullable: false,
+    unique: false,
+  })
+  public postmortemNote?: string = undefined;
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.CreateIncidentNoteTemplate,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadIncidentNoteTemplate,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.EditIncidentNoteTemplate,
+    ],
+  })
+  @TableColumn({
+    required: true,
+    type: TableColumnType.ShortText,
+    canReadOnRelationQuery: true,
+    title: "Name",
+    description: "Name of the Postmortem Template",
+  })
+  @Column({
+    nullable: false,
+    type: ColumnType.ShortText,
+    length: ColumnLength.ShortText,
+  })
+  public templateName?: string = undefined;
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.CreateIncidentNoteTemplate,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadIncidentNoteTemplate,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.EditIncidentNoteTemplate,
+    ],
+  })
+  @TableColumn({
+    required: true,
+    type: TableColumnType.LongText,
+    canReadOnRelationQuery: true,
+    title: "Template Description",
+    description: "Description of the Postmortem Template",
+  })
+  @Column({
+    nullable: false,
+    type: ColumnType.LongText,
+    length: ColumnLength.LongText,
+  })
+  public templateDescription?: string = undefined;
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.CreateIncidentNoteTemplate,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadIncidentNoteTemplate,
+    ],
+    update: [],
+  })
+  @TableColumn({
+    manyToOneRelationColumn: "createdByUserId",
+    type: TableColumnType.Entity,
+    modelType: User,
+    title: "Created by User",
+    description:
+      "Relation to User who created this object (if this object was created by a User)",
+  })
+  @ManyToOne(
+    () => {
+      return User;
+    },
+    {
+      eager: false,
+      nullable: true,
+      onDelete: "SET NULL",
+      orphanedRowAction: "nullify",
+    },
+  )
+  @JoinColumn({ name: "createdByUserId" })
+  public createdByUser?: User = undefined;
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.CreateIncidentNoteTemplate,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadIncidentNoteTemplate,
+    ],
+    update: [],
+  })
+  @TableColumn({
+    type: TableColumnType.ObjectID,
+    title: "Created by User ID",
+    description:
+      "User ID who created this object (if this object was created by a User)",
+  })
+  @Column({
+    type: ColumnType.ObjectID,
+    nullable: true,
+    transformer: ObjectID.getDatabaseTransformer(),
+  })
+  public createdByUserId?: ObjectID = undefined;
+
+  @ColumnAccessControl({
+    create: [],
+    read: [],
+    update: [],
+  })
+  @TableColumn({
+    manyToOneRelationColumn: "deletedByUserId",
+    type: TableColumnType.Entity,
+    title: "Deleted by User",
+    modelType: User,
+    description:
+      "Relation to User who deleted this object (if this object was deleted by a User)",
+  })
+  @ManyToOne(
+    () => {
+      return User;
+    },
+    {
+      cascade: false,
+      eager: false,
+      nullable: true,
+      onDelete: "SET NULL",
+      orphanedRowAction: "nullify",
+    },
+  )
+  @JoinColumn({ name: "deletedByUserId" })
+  public deletedByUser?: User = undefined;
+
+  @ColumnAccessControl({
+    create: [],
+    read: [],
+    update: [],
+  })
+  @TableColumn({
+    type: TableColumnType.ObjectID,
+    title: "Deleted by User ID",
+    description:
+      "User ID who deleted this object (if this object was deleted by a User)",
+  })
+  @Column({
+    type: ColumnType.ObjectID,
+    nullable: true,
+    transformer: ObjectID.getDatabaseTransformer(),
+  })
+  public deletedByUserId?: ObjectID = undefined;
+}

package/Models/DatabaseModels/Index.ts

@@ -24,6 +24,7 @@ import IncidentFeed from "./IncidentFeed";
 import IncidentCustomField from "./IncidentCustomField";
 import IncidentInternalNote from "./IncidentInternalNote";
 import IncidentNoteTemplate from "./IncidentNoteTemplate";
+import IncidentPostmortemTemplate from "./IncidentPostmortemTemplate";
 import IncidentOwnerTeam from "./IncidentOwnerTeam";
 import IncidentOwnerUser from "./IncidentOwnerUser";
 import IncidentPublicNote from "./IncidentPublicNote";
@@ -235,6 +236,7 @@ const AllModelTypes: Array<{
   IncidentOwnerUser,
   IncidentSeverity,
   IncidentNoteTemplate,
+  IncidentPostmortemTemplate,
 
   AlertState,
   Alert,

package/Server/Infrastructure/Postgres/SchemaMigrations/1761834523183-MigrationName.ts

@@ -0,0 +1,49 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class MigrationName1761834523183 implements MigrationInterface {
+  public name = "MigrationName1761834523183";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `CREATE TABLE "IncidentPostmortemTemplate" ("_id" uuid NOT NULL DEFAULT uuid_generate_v4(), "createdAt" TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT now(), "updatedAt" TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT now(), "deletedAt" TIMESTAMP WITH TIME ZONE, "version" integer NOT NULL, "projectId" uuid NOT NULL, "postmortemNote" text NOT NULL, "templateName" character varying(100) NOT NULL, "templateDescription" character varying(500) NOT NULL, "createdByUserId" uuid, "deletedByUserId" uuid, CONSTRAINT "PK_76a09ebf10e7874f0c8ee1f0120" PRIMARY KEY ("_id"))`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_2a18729813c7c666cc37683c4e" ON "IncidentPostmortemTemplate" ("projectId") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_c791fe4d7179b57064ace561c3" ON "IncidentPostmortemTemplate" ("postmortemNote") `,
+    );
+    await queryRunner.query(`ALTER TABLE "Incident" ADD "postmortemNote" text`);
+    await queryRunner.query(
+      `ALTER TABLE "IncidentPostmortemTemplate" ADD CONSTRAINT "FK_2a18729813c7c666cc37683c4ea" FOREIGN KEY ("projectId") REFERENCES "Project"("_id") ON DELETE CASCADE ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentPostmortemTemplate" ADD CONSTRAINT "FK_961ac93c4d7ea881170692333d0" FOREIGN KEY ("createdByUserId") REFERENCES "User"("_id") ON DELETE SET NULL ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentPostmortemTemplate" ADD CONSTRAINT "FK_2e886387888f1311f361d569b8e" FOREIGN KEY ("deletedByUserId") REFERENCES "User"("_id") ON DELETE SET NULL ON UPDATE NO ACTION`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "IncidentPostmortemTemplate" DROP CONSTRAINT "FK_2e886387888f1311f361d569b8e"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentPostmortemTemplate" DROP CONSTRAINT "FK_961ac93c4d7ea881170692333d0"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentPostmortemTemplate" DROP CONSTRAINT "FK_2a18729813c7c666cc37683c4ea"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "Incident" DROP COLUMN "postmortemNote"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_c791fe4d7179b57064ace561c3"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_2a18729813c7c666cc37683c4e"`,
+    );
+    await queryRunner.query(`DROP TABLE "IncidentPostmortemTemplate"`);
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/Index.ts

@@ -178,6 +178,7 @@ import { MigrationName1759943124812 } from "./1759943124812-MigrationName";
 import { MigrationName1760345757975 } from "./1760345757975-MigrationName";
 import { MigrationName1760357680881 } from "./1760357680881-MigrationName";
 import { MigrationName1761232578396 } from "./1761232578396-MigrationName";
+import { MigrationName1761834523183 } from "./1761834523183-MigrationName";
 
 export default [
   InitialMigration,
@@ -360,4 +361,5 @@ export default [
   MigrationName1760345757975,
   MigrationName1760357680881,
   MigrationName1761232578396,
+  MigrationName1761834523183,
 ];

package/Server/Services/IncidentPostmortemTemplateService.ts

@@ -0,0 +1,10 @@
+import DatabaseService from "./DatabaseService";
+import Model from "../../Models/DatabaseModels/IncidentPostmortemTemplate";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+  }
+}
+
+export default new Service();

package/Server/Services/IncidentService.ts

@@ -49,7 +49,7 @@ import Semaphore, {
 } from "../../Server/Infrastructure/Semaphore";
 import IncidentFeedService from "./IncidentFeedService";
 import { IncidentFeedEventType } from "../../Models/DatabaseModels/IncidentFeed";
-import { Gray500, Red500 } from "../../Types/BrandColors";
+import { Blue500, Gray500, Red500 } from "../../Types/BrandColors";
 import Label from "../../Models/DatabaseModels/Label";
 import LabelService from "./LabelService";
 import IncidentSeverity from "../../Models/DatabaseModels/IncidentSeverity";
@@ -74,6 +74,17 @@ type UpdateCarryForward = Dictionary<{
   newMonitorChangeStatusIdTo: ObjectID | undefined;
 }>;
 
+type IncidentUpdatePayload = {
+  postmortemNote?: string | null;
+  title?: string | null;
+  rootCause?: string | null;
+  description?: string | null;
+  remediationNotes?: string | null;
+  labels?: unknown;
+  incidentSeverity?: unknown;
+  [key: string]: unknown;
+};
+
 export class Service extends DatabaseService<Model> {
   public constructor() {
     super(Model);
@@ -1297,59 +1308,103 @@ ${incident.remediationNotes || "No remediation notes provided."}
 
         const projectId: ObjectID = incident!.projectId!;
         const incidentNumber: number = incident!.incidentNumber!;
+        const incidentLabel: string = `Incident ${incidentNumber}`;
+        const incidentLink: URL = await this.getIncidentLinkInDashboard(
+          projectId,
+          incidentId,
+        );
 
-        let shouldAddIncidentFeed: boolean = false;
-        let feedInfoInMarkdown: string = `**[Incident ${incidentNumber}](${(await this.getIncidentLinkInDashboard(projectId!, incidentId!)).toString()}) was updated.**`;
+        const updatedIncidentData: IncidentUpdatePayload = (onUpdate.updateBy
+          .data ?? {}) as IncidentUpdatePayload;
 
         const createdByUserId: ObjectID | undefined | null =
           onUpdate.updateBy.props.userId;
 
-        if (onUpdate.updateBy.data.title) {
-          // add incident feed.
+        if (
+          Object.prototype.hasOwnProperty.call(
+            updatedIncidentData,
+            "postmortemNote",
+          )
+        ) {
+          const noteValue: string =
+            (updatedIncidentData.postmortemNote as string) || "";
+          const hasNoteContent: boolean = noteValue.trim().length > 0;
 
-          feedInfoInMarkdown += `\n\n**Title**: 
-${onUpdate.updateBy.data.title || "No title provided."}
-`;
-          shouldAddIncidentFeed = true;
+          const postmortemFeedMarkdown: string = hasNoteContent
+            ? `**📘 Postmortem Note updated for [${incidentLabel}](${incidentLink.toString()})**\n\n${noteValue}`
+            : `**📘 Postmortem Note cleared for [${incidentLabel}](${incidentLink.toString()})**\n\n_No postmortem note provided._`;
+
+          await IncidentFeedService.createIncidentFeedItem({
+            incidentId,
+            projectId,
+            incidentFeedEventType: IncidentFeedEventType.PostmortemNote,
+            displayColor: Blue500,
+            feedInfoInMarkdown: postmortemFeedMarkdown,
+            userId: createdByUserId || undefined,
+            workspaceNotification: {
+              sendWorkspaceNotification: true,
+            },
+          });
         }
 
-        if (onUpdate.updateBy.data.rootCause) {
-          if (onUpdate.updateBy.data.title) {
-            // add incident feed.
+        let shouldAddIncidentFeed: boolean = false;
+        let feedInfoInMarkdown: string = `**[${incidentLabel}](${incidentLink.toString()}) was updated.**`;
 
-            feedInfoInMarkdown += `\n\n**📄 Root Cause**: 
-${onUpdate.updateBy.data.rootCause || "No root cause provided."}
-  `;
-            shouldAddIncidentFeed = true;
-          }
+        if (
+          Object.prototype.hasOwnProperty.call(updatedIncidentData, "title")
+        ) {
+          const title: string =
+            (updatedIncidentData.title as string) || "No title provided.";
+          feedInfoInMarkdown += `\n\n**Title**: \n${title}\n`;
+          shouldAddIncidentFeed = true;
         }
 
-        if (onUpdate.updateBy.data.description) {
-          // add incident feed.
-
-          feedInfoInMarkdown += `\n\n**Incident Description**: 
-          ${onUpdate.updateBy.data.description || "No description provided."}
-          `;
+        if (
+          Object.prototype.hasOwnProperty.call(updatedIncidentData, "rootCause")
+        ) {
+          const rootCause: string =
+            (updatedIncidentData.rootCause as string) || "";
+          const rootCauseText: string = rootCause.trim().length
+            ? rootCause
+            : "Root cause removed.";
+          feedInfoInMarkdown += `\n\n**📄 Root Cause**: \n${rootCauseText}\n`;
           shouldAddIncidentFeed = true;
         }
 
-        if (onUpdate.updateBy.data.remediationNotes) {
-          // add incident feed.
+        if (
+          Object.prototype.hasOwnProperty.call(
+            updatedIncidentData,
+            "description",
+          )
+        ) {
+          const description: string =
+            (updatedIncidentData.description as string) ||
+            "No description provided.";
+          feedInfoInMarkdown += `\n\n**Incident Description**: \n${description}\n`;
+          shouldAddIncidentFeed = true;
+        }
 
-          feedInfoInMarkdown += `\n\n**🎯 Remediation Notes**: 
-${onUpdate.updateBy.data.remediationNotes || "No remediation notes provided."}
-        `;
+        if (
+          Object.prototype.hasOwnProperty.call(
+            updatedIncidentData,
+            "remediationNotes",
+          )
+        ) {
+          const remediationNotes: string =
+            (updatedIncidentData.remediationNotes as string) || "";
+          const remediationText: string = remediationNotes.trim().length
+            ? remediationNotes
+            : "Remediation notes removed.";
+          feedInfoInMarkdown += `\n\n**🎯 Remediation Notes**: \n${remediationText}\n`;
           shouldAddIncidentFeed = true;
         }
 
         if (
-          onUpdate.updateBy.data.labels &&
-          onUpdate.updateBy.data.labels.length > 0 &&
-          Array.isArray(onUpdate.updateBy.data.labels)
+          updatedIncidentData.labels &&
+          (updatedIncidentData.labels as Array<Label>).length > 0 &&
+          Array.isArray(updatedIncidentData.labels)
         ) {
-          const labelIds: Array<ObjectID> = (
-            onUpdate.updateBy.data.labels as any
-          )
+          const labelIds: Array<ObjectID> = (updatedIncidentData.labels as any)
             .map((label: Label) => {
               if (label._id) {
                 return new ObjectID(label._id?.toString());
@@ -1390,16 +1445,14 @@ ${labels
         }
 
         if (
-          onUpdate.updateBy.data.incidentSeverity &&
-          (onUpdate.updateBy.data.incidentSeverity as any)._id
+          updatedIncidentData.incidentSeverity &&
+          (updatedIncidentData.incidentSeverity as any)._id
         ) {
           const incidentSeverity: IncidentSeverity | null =
             await IncidentSeverityService.findOneBy({
               query: {
                 _id: new ObjectID(
-                  (
-                    onUpdate.updateBy.data.incidentSeverity as any
-                  )?._id.toString(),
+                  (updatedIncidentData.incidentSeverity as any)?._id.toString(),
                 ),
               },
               select: {