@oneuptime/common 7.0.3718 → 7.0.3815

package/Server/Services/IncidentInternalNoteService.ts

@@ -6,12 +6,34 @@ import IncidentFeedService from "./IncidentFeedService";
 import { IncidentFeedEventType } from "../../Models/DatabaseModels/IncidentFeed";
 import { Blue500 } from "../../Types/BrandColors";
 import { LIMIT_PER_PROJECT } from "../../Types/Database/LimitMax";
+import IncidentService from "./IncidentService";
+import Incident from "../../Models/DatabaseModels/Incident";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
     super(Model);
   }
 
+  public async addNote(data: {
+    userId: ObjectID;
+    incidentId: ObjectID;
+    projectId: ObjectID;
+    note: string;
+  }): Promise<Model> {
+    const internalNote: Model = new Model();
+    internalNote.createdByUserId = data.userId;
+    internalNote.incidentId = data.incidentId;
+    internalNote.projectId = data.projectId;
+    internalNote.note = data.note;
+
+    return this.create({
+      data: internalNote,
+      props: {
+        isRoot: true,
+      },
+    });
+  }
+
   public override async onCreateSuccess(
     _onCreate: OnCreate<Model>,
     createdItem: Model,
@@ -19,17 +41,28 @@ export class Service extends DatabaseService<Model> {
     const userId: ObjectID | null | undefined =
       createdItem.createdByUserId || createdItem.createdByUser?.id;
 
-    await IncidentFeedService.createIncidentFeed({
+    const incidentId: ObjectID = createdItem.incidentId!;
+
+    const incidentNumber: number | null =
+      await IncidentService.getIncidentNumber({
+        incidentId: incidentId,
+      });
+
+    await IncidentFeedService.createIncidentFeedItem({
       incidentId: createdItem.incidentId!,
       projectId: createdItem.projectId!,
       incidentFeedEventType: IncidentFeedEventType.PrivateNote,
       displayColor: Blue500,
       userId: userId || undefined,
 
-      feedInfoInMarkdown: `**Posted Internal / Private Note**
+      feedInfoInMarkdown: `📄 posted **private note** for this [Incident ${incidentNumber}](${(await IncidentService.getIncidentLinkInDashboard(createdItem.projectId!, incidentId)).toString()}):
 
 ${createdItem.note}
           `,
+      workspaceNotification: {
+        sendWorkspaceNotification: true,
+        notifyUserId: userId || undefined,
+      },
     });
 
     return createdItem;
@@ -49,6 +82,10 @@ ${createdItem.note}
         },
         select: {
           incidentId: true,
+          incident: {
+            projectId: true,
+            incidentNumber: true,
+          },
           projectId: true,
           note: true,
           createdByUserId: true,
@@ -62,17 +99,23 @@ ${createdItem.note}
         onUpdate.updateBy.props.userId;
 
       for (const updatedItem of updatedItems) {
-        await IncidentFeedService.createIncidentFeed({
+        const incident: Incident = updatedItem.incident!;
+
+        await IncidentFeedService.createIncidentFeedItem({
           incidentId: updatedItem.incidentId!,
           projectId: updatedItem.projectId!,
           incidentFeedEventType: IncidentFeedEventType.PrivateNote,
           displayColor: Blue500,
           userId: userId || undefined,
 
-          feedInfoInMarkdown: `**Updated Internal / Private Note**
+          feedInfoInMarkdown: `📄 updated **Private Note** for this [Incident ${incident.incidentNumber}](${(await IncidentService.getIncidentLinkInDashboard(incident.projectId!, incident.id!)).toString()})
 
 ${updatedItem.note}
           `,
+          workspaceNotification: {
+            sendWorkspaceNotification: true,
+            notifyUserId: userId || undefined,
+          },
         });
       }
     }

package/Server/Services/IncidentOwnerTeamService.ts

@@ -8,6 +8,11 @@ import { Gray500, Red500 } from "../../Types/BrandColors";
 import TeamService from "./TeamService";
 import Team from "../../Models/DatabaseModels/Team";
 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";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
@@ -64,14 +69,23 @@ export class Service extends DatabaseService<Model> {
           },
         });
 
+        const incidentNumber: number | null =
+          await IncidentService.getIncidentNumber({
+            incidentId: incidentId,
+          });
+
         if (team && team.name) {
-          await IncidentFeedService.createIncidentFeed({
+          await IncidentFeedService.createIncidentFeedItem({
             incidentId: incidentId,
             projectId: projectId,
             incidentFeedEventType: IncidentFeedEventType.OwnerTeamRemoved,
             displayColor: Red500,
-            feedInfoInMarkdown: `**Team ${team.name}** was removed from the incident as the owner.`,
+            feedInfoInMarkdown: `👨🏻‍👩🏻‍👦🏻 Removed team **${team.name}** from the [Incident ${incidentNumber}](${(await IncidentService.getIncidentLinkInDashboard(projectId!, incidentId!)).toString()}) as the owner.`,
             userId: deleteByUserId || undefined,
+            workspaceNotification: {
+              sendWorkspaceNotification: true,
+              notifyUserId: deleteByUserId || undefined,
+            },
           });
         }
       }
@@ -104,17 +118,56 @@ export class Service extends DatabaseService<Model> {
       });
 
       if (team && team.name) {
-        await IncidentFeedService.createIncidentFeed({
+        const incidentNumber: number | null =
+          await IncidentService.getIncidentNumber({
+            incidentId: incidentId,
+          });
+
+        await IncidentFeedService.createIncidentFeedItem({
           incidentId: incidentId,
           projectId: projectId,
           incidentFeedEventType: IncidentFeedEventType.OwnerTeamAdded,
           displayColor: Gray500,
-          feedInfoInMarkdown: `**Team ${team.name}** was added to the incident as the owner.`,
+          feedInfoInMarkdown: `👨🏻‍👩🏻‍👦🏻 Added team **${team.name}** to the [Incident ${incidentNumber}](${(await IncidentService.getIncidentLinkInDashboard(projectId!, incidentId!)).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: {
+            incidentId: incidentId,
+          },
+          notificationRuleEventType: NotificationRuleEventType.Incident,
+        },
+      );
+
+    logger.debug(`Notification Rules for Incident Owner Teams`);
+    logger.debug(notificationRules);
+
+    WorkspaceNotificationRuleService.inviteTeamsBasedOnRulesAndWorkspaceChannels(
+      {
+        notificationRules: notificationRules,
+        projectId: projectId!,
+        workspaceChannels: await IncidentService.getWorkspaceChannelForIncident(
+          {
+            incidentId: incidentId!,
+          },
+        ),
+        teamIds: [teamId!],
+      },
+    ).catch((error: Error) => {
+      logger.error(error);
+    });
+
     return createdItem;
   }
 }

package/Server/Services/IncidentOwnerUserService.ts

@@ -8,6 +8,11 @@ import User from "../../Models/DatabaseModels/User";
 import UserService from "./UserService";
 import { OnCreate, OnDelete } from "../Types/Database/Hooks";
 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";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
@@ -65,14 +70,23 @@ export class Service extends DatabaseService<Model> {
           },
         });
 
+        const incidentNumber: number | null =
+          await IncidentService.getIncidentNumber({
+            incidentId: incidentId,
+          });
+
         if (user && user.name) {
-          await IncidentFeedService.createIncidentFeed({
+          await IncidentFeedService.createIncidentFeedItem({
             incidentId: incidentId,
             projectId: projectId,
             incidentFeedEventType: IncidentFeedEventType.OwnerUserRemoved,
             displayColor: Red500,
-            feedInfoInMarkdown: `**${user.name.toString()}** (${user.email?.toString()}) was removed from the incident as the owner.`,
+            feedInfoInMarkdown: `👨🏻‍💻 Removed **${user.name.toString()}** (${user.email?.toString()}) from the [Incident ${incidentNumber}](${(await IncidentService.getIncidentLinkInDashboard(projectId!, incidentId!)).toString()}) as the owner.`,
             userId: deleteByUserId || undefined,
+            workspaceNotification: {
+              sendWorkspaceNotification: true,
+              notifyUserId: userId || undefined,
+            },
           });
         }
       }
@@ -94,29 +108,59 @@ export class Service extends DatabaseService<Model> {
       createdItem.createdByUserId || onCreate.createBy.props.userId;
 
     if (incidentId && userId && projectId) {
-      const user: User | null = await UserService.findOneById({
-        id: userId,
-        select: {
-          name: true,
-          email: true,
-        },
-        props: {
-          isRoot: true,
-        },
-      });
+      const incidentNumber: number | null =
+        await IncidentService.getIncidentNumber({
+          incidentId: incidentId,
+        });
 
-      if (user && user.name) {
-        await IncidentFeedService.createIncidentFeed({
+      if (userId) {
+        await IncidentFeedService.createIncidentFeedItem({
           incidentId: incidentId,
           projectId: projectId,
           incidentFeedEventType: IncidentFeedEventType.OwnerUserAdded,
           displayColor: Gray500,
-          feedInfoInMarkdown: `**${user.name.toString()}** (${user.email?.toString()}) was added to the incident as the owner.`,
+          feedInfoInMarkdown: `👨🏻‍💻 Added **${await UserService.getUserMarkdownString(
+            {
+              userId: userId,
+              projectId: projectId,
+            },
+          )}** to the [Incident ${incidentNumber}](${(await IncidentService.getIncidentLinkInDashboard(projectId!, incidentId!)).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: {
+            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;
   }
 }

package/Server/Services/IncidentPublicNoteService.ts

@@ -8,12 +8,35 @@ import { IncidentFeedEventType } from "../../Models/DatabaseModels/IncidentFeed"
 import { Blue500, Indigo500 } from "../../Types/BrandColors";
 import ObjectID from "../../Types/ObjectID";
 import { LIMIT_PER_PROJECT } from "../../Types/Database/LimitMax";
+import IncidentService from "./IncidentService";
+import Incident from "../../Models/DatabaseModels/Incident";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
     super(Model);
   }
 
+  public async addNote(data: {
+    userId: ObjectID;
+    incidentId: ObjectID;
+    projectId: ObjectID;
+    note: string;
+  }): Promise<Model> {
+    const publicNote: Model = new Model();
+    publicNote.createdByUserId = data.userId;
+    publicNote.incidentId = data.incidentId;
+    publicNote.projectId = data.projectId;
+    publicNote.note = data.note;
+    publicNote.postedAt = OneUptimeDate.getCurrentDate();
+
+    return this.create({
+      data: publicNote,
+      props: {
+        isRoot: true,
+      },
+    });
+  }
+
   protected override async onBeforeCreate(
     createBy: CreateBy<Model>,
   ): Promise<OnCreate<Model>> {
@@ -34,16 +57,27 @@ export class Service extends DatabaseService<Model> {
     const userId: ObjectID | null | undefined =
       createdItem.createdByUserId || createdItem.createdByUser?.id;
 
-    await IncidentFeedService.createIncidentFeed({
+    const incidentId: ObjectID = createdItem.incidentId!;
+    const projectId: ObjectID = createdItem.projectId!;
+    const incidentNumber: number | null =
+      await IncidentService.getIncidentNumber({
+        incidentId: incidentId,
+      });
+
+    await IncidentFeedService.createIncidentFeedItem({
       incidentId: createdItem.incidentId!,
       projectId: createdItem.projectId!,
       incidentFeedEventType: IncidentFeedEventType.PublicNote,
       displayColor: Indigo500,
       userId: userId || undefined,
-      feedInfoInMarkdown: `**Posted public note for this incident on status page**
+      feedInfoInMarkdown: `📄 posted **public note** for this [Incident ${incidentNumber}](${(await IncidentService.getIncidentLinkInDashboard(projectId!, incidentId!)).toString()}) on status page:
 
 ${createdItem.note}
           `,
+      workspaceNotification: {
+        sendWorkspaceNotification: true,
+        notifyUserId: userId || undefined,
+      },
     });
 
     return createdItem;
@@ -76,17 +110,23 @@ ${createdItem.note}
         onUpdate.updateBy.props.userId;
 
       for (const updatedItem of updatedItems) {
-        await IncidentFeedService.createIncidentFeed({
+        const incident: Incident = updatedItem.incident!;
+
+        await IncidentFeedService.createIncidentFeedItem({
           incidentId: updatedItem.incidentId!,
           projectId: updatedItem.projectId!,
-          incidentFeedEventType: IncidentFeedEventType.PublicNote,
+          incidentFeedEventType: IncidentFeedEventType.PrivateNote,
           displayColor: Blue500,
           userId: userId || undefined,
 
-          feedInfoInMarkdown: `**Updated Public Note**
-  
+          feedInfoInMarkdown: `📄 updated **Public Note** for this [Incident ${incident.incidentNumber}](${(await IncidentService.getIncidentLinkInDashboard(incident.projectId!, incident.id!)).toString()})
+        
 ${updatedItem.note}
-            `,
+                  `,
+          workspaceNotification: {
+            sendWorkspaceNotification: true,
+            notifyUserId: userId || undefined,
+          },
         });
       }
     }