@oneuptime/common 7.0.3717 → 7.0.3786

package/Server/Services/IncidentStateTimelineService.ts

@@ -17,7 +17,6 @@ import Incident from "Common/Models/DatabaseModels/Incident";
 import IncidentPublicNote from "Common/Models/DatabaseModels/IncidentPublicNote";
 import IncidentState from "Common/Models/DatabaseModels/IncidentState";
 import IncidentStateTimeline from "Common/Models/DatabaseModels/IncidentStateTimeline";
-import User from "Common/Models/DatabaseModels/User";
 import { IsBillingEnabled } from "../EnvironmentConfig";
 import logger from "../Utils/Logger";
 import IncidentFeedService from "./IncidentFeedService";
@@ -82,22 +81,13 @@ export class Service extends DatabaseService<IncidentStateTimeline> {
         userId = createBy.data.createdByUser.id;
       }
 
-      const user: User | null = await UserService.findOneBy({
-        query: {
-          _id: userId?.toString() as string,
-        },
-        select: {
-          _id: true,
-          name: true,
-          email: true,
-        },
-        props: {
-          isRoot: true,
-        },
-      });
-
-      if (user) {
-        createBy.data.rootCause = `Incident state created by ${user.name} (${user.email})`;
+      if (userId) {
+        createBy.data.rootCause = `Incident state created by ${await UserService.getUserMarkdownString(
+          {
+            userId: userId!,
+            projectId: createBy.data.projectId || createBy.props.tenantId!,
+          },
+        )}`;
       }
     }
 
@@ -195,16 +185,44 @@ export class Service extends DatabaseService<IncidentStateTimeline> {
       });
 
     const stateName: string = incidentState?.name || "";
+    let stateEmoji: string = "➡️";
+
+    // if resolved state then change emoji to ✅.
+
+    if (incidentState?.isResolvedState) {
+      stateEmoji = "✅";
+    } else if (incidentState?.isAcknowledgedState) {
+      // eyes emoji for acknowledged state.
+      stateEmoji = "👀";
+    } else if (incidentState?.isCreatedState) {
+      stateEmoji = "🔴";
+    }
 
-    await IncidentFeedService.createIncidentFeed({
+    const incidentNumber: number | null =
+      await IncidentService.getIncidentNumber({
+        incidentId: createdItem.incidentId,
+      });
+
+    const projectId: ObjectID = createdItem.projectId!;
+    const incidentId: ObjectID = createdItem.incidentId!;
+
+    await IncidentFeedService.createIncidentFeedItem({
       incidentId: createdItem.incidentId!,
       projectId: createdItem.projectId!,
       incidentFeedEventType: IncidentFeedEventType.IncidentStateChanged,
       displayColor: incidentState?.color,
-      feedInfoInMarkdown: "**Incident State** changed to **" + stateName + "**",
+      feedInfoInMarkdown:
+        stateEmoji +
+        ` Changed **[Incident ${incidentNumber}](${(await IncidentService.getIncidentLinkInDashboard(projectId!, incidentId!)).toString()}) State** to **` +
+        stateName +
+        "**",
       moreInformationInMarkdown: `**Cause:** 
 ${createdItem.rootCause}`,
       userId: createdItem.createdByUserId || onCreate.createBy.props.userId,
+      workspaceNotification: {
+        sendWorkspaceNotification: true,
+        notifyUserId: createdItem.createdByUserId,
+      },
     });
 
     const isResolvedState: boolean = incidentState?.isResolvedState || false;

package/Server/Services/MonitorStatusTimelineService.ts

@@ -13,7 +13,6 @@ import BadDataException from "../../Types/Exception/BadDataException";
 import ObjectID from "../../Types/ObjectID";
 import PositiveNumber from "../../Types/PositiveNumber";
 import MonitorStatusTimeline from "Common/Models/DatabaseModels/MonitorStatusTimeline";
-import User from "Common/Models/DatabaseModels/User";
 import { IsBillingEnabled } from "../EnvironmentConfig";
 
 export class Service extends DatabaseService<MonitorStatusTimeline> {
@@ -62,22 +61,13 @@ export class Service extends DatabaseService<MonitorStatusTimeline> {
         userId = createBy.data.createdByUser.id;
       }
 
-      const user: User | null = await UserService.findOneBy({
-        query: {
-          _id: userId?.toString() as string,
-        },
-        select: {
-          _id: true,
-          name: true,
-          email: true,
-        },
-        props: {
-          isRoot: true,
-        },
-      });
-
-      if (user) {
-        createBy.data.rootCause = `Monitor status created by ${user.name} (${user.email})`;
+      if (userId) {
+        createBy.data.rootCause = `Monitor status created by ${await UserService.getUserMarkdownString(
+          {
+            userId: userId!,
+            projectId: createBy.data.projectId || createBy.props.tenantId!,
+          },
+        )}`;
       }
     }
 

package/Server/Services/OnCallDutyPolicyEscalationRuleService.ts

@@ -188,6 +188,8 @@ export class Service extends DatabaseService<Model> {
         teamId: ObjectID | null,
         scheduleId: ObjectID | null,
       ): Promise<void> => {
+        // This is where user is notified.
+
         logger.debug(
           `Starting notification rule execution for userId: ${userId.toString()}`,
         );

package/Server/Services/OnCallDutyPolicyExecutionLogService.ts

@@ -17,6 +17,8 @@ import Color from "../../Types/Color";
 import AlertFeedService from "./AlertFeedService";
 import { AlertFeedEventType } from "../../Models/DatabaseModels/AlertFeed";
 import BadDataException from "../../Types/Exception/BadDataException";
+import IncidentService from "./IncidentService";
+import AlertService from "./AlertService";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
@@ -65,24 +67,47 @@ export class Service extends DatabaseService<Model> {
         });
 
       if (onCallPolicy && onCallPolicy.id) {
-        const feedInfoInMarkdown: string = `**On Call Policy Started Executing:** On Call Policy **${onCallPolicy.name}** started executing. Users on call on this policy will now be notified.`;
+        let incidentOrAlertLink: string = "";
+
+        if (createdItem.triggeredByIncidentId) {
+          const projectId: ObjectID | undefined = createdItem.projectId;
+          const incidentId: ObjectID | undefined =
+            createdItem.triggeredByIncidentId;
+          const incidentNumber: number | null =
+            await IncidentService.getIncidentNumber({
+              incidentId: incidentId,
+            });
+          incidentOrAlertLink = `[Incident ${incidentNumber}](${(await IncidentService.getIncidentLinkInDashboard(projectId!, incidentId!)).toString()})`;
+        }
+
+        if (createdItem.triggeredByAlertId) {
+          const alertNumber: number | null = await AlertService.getAlertNumber({
+            alertId: createdItem.triggeredByAlertId,
+          });
+          incidentOrAlertLink = `[Alert ${alertNumber}](${(await AlertService.getAlertLinkInDashboard(createdItem.projectId!, createdItem.triggeredByAlertId)).toString()})`;
+        }
+
+        const feedInfoInMarkdown: string = `**📞 On Call Policy Started Executing:** On Call Policy **${onCallPolicy.name}** started executing for ${incidentOrAlertLink}. Users on call on this policy will now be notified.`;
 
         if (
           onCallPolicy &&
           onCallPolicy.id &&
           createdItem.triggeredByIncidentId
         ) {
-          await IncidentFeedService.createIncidentFeed({
+          await IncidentFeedService.createIncidentFeedItem({
             incidentId: createdItem.triggeredByIncidentId,
             projectId: createdItem.projectId!,
             incidentFeedEventType: IncidentFeedEventType.OnCallPolicy,
             displayColor: Yellow500,
             feedInfoInMarkdown: feedInfoInMarkdown,
+            workspaceNotification: {
+              sendWorkspaceNotification: true,
+            },
           });
         }
 
         if (onCallPolicy && onCallPolicy.id && createdItem.triggeredByAlertId) {
-          await AlertFeedService.createAlertFeed({
+          await AlertFeedService.createAlertFeedItem({
             alertId: createdItem.triggeredByAlertId,
             projectId: createdItem.projectId!,
             alertFeedEventType: AlertFeedEventType.OnCallPolicy,
@@ -191,6 +216,23 @@ export class Service extends DatabaseService<Model> {
     }
   }
 
+  public getEmojiByStatus(status: OnCallDutyPolicyStatus | undefined): string {
+    switch (status) {
+      case OnCallDutyPolicyStatus.Scheduled:
+        return "📅";
+      case OnCallDutyPolicyStatus.Started:
+        return "🚀";
+      case OnCallDutyPolicyStatus.Executing:
+        return "▶️";
+      case OnCallDutyPolicyStatus.Completed:
+        return "🏁";
+      case OnCallDutyPolicyStatus.Error:
+        return "❌";
+      default:
+        return "📅";
+    }
+  }
+
   protected override async onUpdateSuccess(
     onUpdate: OnUpdate<Model>,
     _updatedItemIds: Array<ObjectID>,
@@ -240,12 +282,34 @@ export class Service extends DatabaseService<Model> {
 
 **Message:** ${onCalldutyPolicyExecutionLog.statusMessage}`;
 
-          const feedInfoInMarkdown: string = `**On Call Policy Status Updated:**
+          let incidentOrAlertLink: string = "";
+
+          if (onCalldutyPolicyExecutionLog.triggeredByIncidentId) {
+            const projectId: ObjectID | undefined =
+              onCalldutyPolicyExecutionLog.projectId;
+            const incidentId: ObjectID | undefined =
+              onCalldutyPolicyExecutionLog.triggeredByIncidentId;
+            const incidentNumber: number | null =
+              await IncidentService.getIncidentNumber({
+                incidentId: incidentId,
+              });
+            incidentOrAlertLink = `[Incident ${incidentNumber}](${(await IncidentService.getIncidentLinkInDashboard(projectId!, incidentId!)).toString()})`;
+          }
+
+          if (onCalldutyPolicyExecutionLog.triggeredByAlertId) {
+            const alertNumber: number | null =
+              await AlertService.getAlertNumber({
+                alertId: onCalldutyPolicyExecutionLog.triggeredByAlertId,
+              });
+            incidentOrAlertLink = `[Alert ${alertNumber}](${(await AlertService.getAlertLinkInDashboard(onCalldutyPolicyExecutionLog.projectId!, onCalldutyPolicyExecutionLog.triggeredByAlertId)).toString()})`;
+          }
+
+          const feedInfoInMarkdown: string = `**${this.getEmojiByStatus(onCalldutyPolicyExecutionLog.status)} On Call Policy Status Updated for ${incidentOrAlertLink}:**
 
-On-call policy **${onCallPolicy.name}** status updated to **${onCalldutyPolicyExecutionLog.status}**`;
+ On-call policy **[${onCallPolicy.name?.toString()}](${(await OnCallDutyPolicyService.getOnCallPolicyLinkInDashboard(onCallPolicy.projectId!, onCallPolicy.id!)).toString()})** status updated to **${onCalldutyPolicyExecutionLog.status}**`;
 
           if (onCalldutyPolicyExecutionLog.triggeredByIncidentId) {
-            await IncidentFeedService.createIncidentFeed({
+            await IncidentFeedService.createIncidentFeedItem({
               incidentId: onCalldutyPolicyExecutionLog.triggeredByIncidentId,
               projectId: onCalldutyPolicyExecutionLog.projectId!,
               incidentFeedEventType: IncidentFeedEventType.OnCallPolicy,
@@ -256,11 +320,14 @@ On-call policy **${onCallPolicy.name}** status updated to **${onCalldutyPolicyEx
                 : Blue500,
               moreInformationInMarkdown: moreInformationInMarkdown,
               feedInfoInMarkdown: feedInfoInMarkdown,
+              workspaceNotification: {
+                sendWorkspaceNotification: true,
+              },
             });
           }
 
           if (onCalldutyPolicyExecutionLog.triggeredByAlertId) {
-            await AlertFeedService.createAlertFeed({
+            await AlertFeedService.createAlertFeedItem({
               alertId: onCalldutyPolicyExecutionLog.triggeredByAlertId,
               projectId: onCalldutyPolicyExecutionLog.projectId!,
               alertFeedEventType: AlertFeedEventType.OnCallPolicy,

package/Server/Services/OnCallDutyPolicyExecutionLogTimelineService.ts

@@ -11,6 +11,10 @@ import logger from "../Utils/Logger";
 import { LIMIT_PER_PROJECT } from "../../Types/Database/LimitMax";
 import AlertFeedService from "./AlertFeedService";
 import { AlertFeedEventType } from "../../Models/DatabaseModels/AlertFeed";
+import OnCallDutyPolicyService from "./OnCallDutyPolicyService";
+import AlertService from "./AlertService";
+import IncidentService from "./IncidentService";
+import UserService from "./UserService";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
@@ -38,6 +42,27 @@ export class Service extends DatabaseService<Model> {
     }
   }
 
+  public getEmojiBasedOnStatus(
+    status: OnCallDutyExecutionLogTimelineStatus,
+  ): string {
+    switch (status) {
+      case OnCallDutyExecutionLogTimelineStatus.Started:
+        return "🚀";
+      case OnCallDutyExecutionLogTimelineStatus.Executing:
+        return "🔄";
+      case OnCallDutyExecutionLogTimelineStatus.Error:
+        return "❌";
+      case OnCallDutyExecutionLogTimelineStatus.NotificationSent:
+        return "📧";
+      case OnCallDutyExecutionLogTimelineStatus.Skipped:
+        return "🚫";
+      case OnCallDutyExecutionLogTimelineStatus.SuccessfullyAcknowledged:
+        return "✅";
+      default:
+        return "🚀";
+    }
+  }
+
   public async addToIncidentOrAlertFeed(data: {
     onCallDutyPolicyExecutionLogTimelineId: ObjectID;
   }): Promise<void> {
@@ -120,25 +145,59 @@ export class Service extends DatabaseService<Model> {
           ? this.getColorBasedOnStatus(status)
           : Blue500;
 
-        const feedInfoInMarkdown: string = `**On-call alert ${status} to ${onCallDutyPolicyExecutionLogTimeline.alertSentToUser?.name?.toString().trim()}**
+        let incidentOrAlertLink: string = "";
 
-The on-call policy **${onCallDutyPolicyExecutionLogTimeline.onCallDutyPolicy.name}** has been triggered. The escalation rule **${onCallDutyPolicyExecutionLogTimeline.onCallDutyPolicyEscalationRule?.name}** ${onCallDutyPolicyExecutionLogTimeline.onCallDutySchedule?.name ? String(" and schedule **" + onCallDutyPolicyExecutionLogTimeline.onCallDutySchedule?.name + "**") : ""} were applied. The user **${onCallDutyPolicyExecutionLogTimeline.alertSentToUser?.name}** (${onCallDutyPolicyExecutionLogTimeline.alertSentToUser?.email}) was alerted. The status of this alert is **${status}** with the message: \`${onCallDutyPolicyExecutionLogTimeline.statusMessage}\`. ${onCallDutyPolicyExecutionLogTimeline.userBelongsToTeam?.name ? "The alert was sent because the user belogs to the team **" + onCallDutyPolicyExecutionLogTimeline.userBelongsToTeam?.name + "**" : ""} ${onCallDutyPolicyExecutionLogTimeline.isAcknowledged ? "The alert was acknowledged at **" + onCallDutyPolicyExecutionLogTimeline.acknowledgedAt + "**" : ""}`;
+        if (onCallDutyPolicyExecutionLogTimeline.triggeredByIncidentId) {
+          const projectId: ObjectID | undefined =
+            onCallDutyPolicyExecutionLogTimeline.projectId;
+          const incidentId: ObjectID | undefined =
+            onCallDutyPolicyExecutionLogTimeline.triggeredByIncidentId;
+          const incidentNumber: number | null =
+            await IncidentService.getIncidentNumber({
+              incidentId: incidentId,
+            });
+          incidentOrAlertLink = `[Incident ${incidentNumber}](${(await IncidentService.getIncidentLinkInDashboard(projectId!, incidentId!)).toString()})`;
+        }
+
+        if (onCallDutyPolicyExecutionLogTimeline.triggeredByAlertId) {
+          const alertNumber: number | null = await AlertService.getAlertNumber({
+            alertId: onCallDutyPolicyExecutionLogTimeline.triggeredByAlertId,
+          });
+          incidentOrAlertLink = `[Alert ${alertNumber}](${(await AlertService.getAlertLinkInDashboard(onCallDutyPolicyExecutionLogTimeline.projectId!, onCallDutyPolicyExecutionLogTimeline.triggeredByAlertId)).toString()})`;
+        }
+
+        const feedInfoInMarkdown: string = `**${this.getEmojiBasedOnStatus(status)} ${incidentOrAlertLink} On-Call Alert ${status} to ${await UserService.getUserMarkdownString(
+          {
+            userId: onCallDutyPolicyExecutionLogTimeline.alertSentToUserId!,
+            projectId: onCallDutyPolicyExecutionLogTimeline.projectId!,
+          },
+        )}**
+
+The on-call policy **[${onCallDutyPolicyExecutionLogTimeline.onCallDutyPolicy.name}](${(await OnCallDutyPolicyService.getOnCallPolicyLinkInDashboard(onCallDutyPolicyExecutionLogTimeline.projectId!, onCallDutyPolicyExecutionLogTimeline.onCallDutyPolicy.id!)).toString()})** has been triggered. The escalation rule **${onCallDutyPolicyExecutionLogTimeline.onCallDutyPolicyEscalationRule?.name}** ${onCallDutyPolicyExecutionLogTimeline.onCallDutySchedule?.name ? String(" and schedule **" + onCallDutyPolicyExecutionLogTimeline.onCallDutySchedule?.name + "**") : ""} were applied. ${await UserService.getUserMarkdownString(
+          {
+            userId: onCallDutyPolicyExecutionLogTimeline.alertSentToUserId!,
+            projectId: onCallDutyPolicyExecutionLogTimeline.projectId!,
+          },
+        )} was alerted. The status of this alert is **${status}** with the message: \`${onCallDutyPolicyExecutionLogTimeline.statusMessage}\`. ${onCallDutyPolicyExecutionLogTimeline.userBelongsToTeam?.name ? "The alert was sent because the user belogs to the team **" + onCallDutyPolicyExecutionLogTimeline.userBelongsToTeam?.name + "**" : ""} ${onCallDutyPolicyExecutionLogTimeline.isAcknowledged ? "The alert was acknowledged at **" + onCallDutyPolicyExecutionLogTimeline.acknowledgedAt + "**" : ""}`;
 
         logger.debug("Feed Info in Markdown: " + feedInfoInMarkdown);
 
         if (onCallDutyPolicyExecutionLogTimeline.triggeredByIncidentId) {
-          await IncidentFeedService.createIncidentFeed({
+          await IncidentFeedService.createIncidentFeedItem({
             incidentId:
               onCallDutyPolicyExecutionLogTimeline.triggeredByIncidentId,
             projectId: onCallDutyPolicyExecutionLogTimeline.projectId!,
             incidentFeedEventType: IncidentFeedEventType.OnCallPolicy,
             displayColor: displayColor,
             feedInfoInMarkdown: feedInfoInMarkdown,
+            workspaceNotification: {
+              sendWorkspaceNotification: true,
+            },
           });
         }
 
         if (onCallDutyPolicyExecutionLogTimeline.triggeredByAlertId) {
-          await AlertFeedService.createAlertFeed({
+          await AlertFeedService.createAlertFeedItem({
             alertId: onCallDutyPolicyExecutionLogTimeline.triggeredByAlertId,
             projectId: onCallDutyPolicyExecutionLogTimeline.projectId!,
             alertFeedEventType: AlertFeedEventType.OnCallPolicy,

package/Server/Services/OnCallDutyPolicyService.ts

@@ -6,12 +6,25 @@ import OnCallDutyPolicyStatus from "../../Types/OnCallDutyPolicy/OnCallDutyPolic
 import UserNotificationEventType from "../../Types/UserNotification/UserNotificationEventType";
 import OnCallDutyPolicy from "Common/Models/DatabaseModels/OnCallDutyPolicy";
 import OnCallDutyPolicyExecutionLog from "Common/Models/DatabaseModels/OnCallDutyPolicyExecutionLog";
+import DatabaseConfig from "../DatabaseConfig";
+import URL from "../../Types/API/URL";
 
 export class Service extends DatabaseService<OnCallDutyPolicy> {
   public constructor() {
     super(OnCallDutyPolicy);
   }
 
+  public async getOnCallPolicyLinkInDashboard(
+    projectId: ObjectID,
+    onCallDutyPolicyId: ObjectID,
+  ): Promise<URL> {
+    const dashboardUrl: URL = await DatabaseConfig.getDashboardUrl();
+
+    return URL.fromString(dashboardUrl.toString()).addRoute(
+      `/${projectId.toString()}/on-call-duty/policies/${onCallDutyPolicyId.toString()}`,
+    );
+  }
+
   public async executePolicy(
     policyId: ObjectID,
     options: {

package/Server/Services/ProjectUserService.ts

@@ -0,0 +1,130 @@
+import TeamMember from "../../Models/DatabaseModels/TeamMember";
+import LIMIT_MAX from "../../Types/Database/LimitMax";
+import ObjectID from "../../Types/ObjectID";
+import DatabaseService from "./DatabaseService";
+import Model from "Common/Models/DatabaseModels/ProjectUser";
+import TeamMemberService from "./TeamMemberService";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+  }
+
+  public async refreshProjectUsersByProject(data: {
+    projectId: ObjectID;
+  }): Promise<void> {
+    // get all team members by user
+
+    // first delete all project users by project id.
+    await this.deleteBy({
+      query: {
+        projectId: data.projectId,
+      },
+      limit: LIMIT_MAX,
+      skip: 0,
+      props: {
+        isRoot: true,
+      },
+    });
+
+    // get all team members by project.
+    const teamMembers: Array<TeamMember> = await TeamMemberService.findBy({
+      query: {
+        projectId: data.projectId,
+      },
+      limit: LIMIT_MAX,
+      skip: 0,
+      props: {
+        isRoot: true,
+      },
+      select: {
+        userId: true,
+        teamId: true,
+        team: {
+          _id: true,
+        },
+        hasAcceptedInvitation: true,
+      },
+    });
+
+    // create project users by team members.
+
+    const projectUsersToCreate: Array<Model> = [];
+
+    for (const teamMember of teamMembers) {
+      // check if the user already exists in the project users.
+
+      // if yes then add the team to the project user acceptedTeams, if the invitation is accepted.
+
+      // if no then create a new project user.
+
+      // if the user is not accepted the invitation then add the team to invitedTeams of the project user.
+
+      // if the user is accepted the invitation then add the team to acceptedTeams of the project user.
+
+      let doesProjectUserExist: boolean = false;
+
+      for (const item of projectUsersToCreate) {
+        if (item.userId?.toString() === teamMember.userId?.toString()) {
+          doesProjectUserExist = true;
+          break;
+        }
+      }
+
+      if (doesProjectUserExist) {
+        // add the team to the project user acceptedTeams, if the invitation is accepted.
+        if (teamMember.hasAcceptedInvitation) {
+          for (const projectUser of projectUsersToCreate) {
+            if (
+              projectUser.userId?.toString() === teamMember.userId?.toString()
+            ) {
+              if (!projectUser.acceptedTeams) {
+                projectUser.acceptedTeams = [];
+              }
+
+              projectUser.acceptedTeams?.push(teamMember.team!);
+            }
+          }
+        } else {
+          for (const projectUser of projectUsersToCreate) {
+            if (
+              projectUser.userId?.toString() === teamMember.userId?.toString()
+            ) {
+              if (!projectUser.invitedTeams) {
+                projectUser.invitedTeams = [];
+              }
+
+              projectUser.invitedTeams?.push(teamMember.team!);
+            }
+          }
+        }
+      } else {
+        // create a new project user.
+        const projectUser: Model = new Model();
+        projectUser.userId = teamMember.userId!;
+        projectUser.projectId = data.projectId;
+
+        if (teamMember.hasAcceptedInvitation) {
+          projectUser.acceptedTeams = [teamMember.team!];
+        } else {
+          projectUser.invitedTeams = [teamMember.team!];
+        }
+
+        projectUsersToCreate.push(projectUser);
+      }
+    }
+
+    // now create the project users.
+
+    for (const projectUser of projectUsersToCreate) {
+      await this.create({
+        data: projectUser,
+        props: {
+          isRoot: true,
+        },
+      });
+    }
+  }
+}
+
+export default new Service();

package/Server/Services/ScheduledMaintenanceFeedService.ts

@@ -19,7 +19,7 @@ export class Service extends DatabaseService<Model> {
     }
   }
 
-  public async createScheduledMaintenanceFeed(data: {
+  public async createScheduledMaintenanceFeedItem(data: {
     scheduledMaintenanceId: ObjectID;
     feedInfoInMarkdown: string;
     scheduledMaintenanceFeedEventType: ScheduledMaintenanceFeedEventType;
@@ -83,7 +83,7 @@ export class Service extends DatabaseService<Model> {
       });
     } catch (error) {
       logger.error(
-        "ScheduledMaintenanceFeedService.createScheduledMaintenanceFeed",
+        "ScheduledMaintenanceFeedService.createScheduledMaintenanceFeedItem",
       );
       logger.error(error);
       // we dont want to throw the error here, as this is not critical but we still log it.

package/Server/Services/ScheduledMaintenanceInternalNoteService.ts

@@ -19,7 +19,7 @@ export class Service extends DatabaseService<Model> {
     const userId: ObjectID | null | undefined =
       createdItem.createdByUserId || createdItem.createdByUser?.id;
 
-    await ScheduledMaintenanceFeedService.createScheduledMaintenanceFeed({
+    await ScheduledMaintenanceFeedService.createScheduledMaintenanceFeedItem({
       scheduledMaintenanceId: createdItem.scheduledMaintenanceId!,
       projectId: createdItem.projectId!,
       scheduledMaintenanceFeedEventType:
@@ -63,19 +63,21 @@ ${createdItem.note}
         onUpdate.updateBy.props.userId;
 
       for (const updatedItem of updatedItems) {
-        await ScheduledMaintenanceFeedService.createScheduledMaintenanceFeed({
-          scheduledMaintenanceId: updatedItem.scheduledMaintenanceId!,
-          projectId: updatedItem.projectId!,
-          scheduledMaintenanceFeedEventType:
-            ScheduledMaintenanceFeedEventType.PrivateNote,
-          displayColor: Blue500,
-          userId: userId || undefined,
+        await ScheduledMaintenanceFeedService.createScheduledMaintenanceFeedItem(
+          {
+            scheduledMaintenanceId: updatedItem.scheduledMaintenanceId!,
+            projectId: updatedItem.projectId!,
+            scheduledMaintenanceFeedEventType:
+              ScheduledMaintenanceFeedEventType.PrivateNote,
+            displayColor: Blue500,
+            userId: userId || undefined,
 
-          feedInfoInMarkdown: `**Updated Private Note**
+            feedInfoInMarkdown: `**Updated Private Note**
       
 ${updatedItem.note}
                 `,
-        });
+          },
+        );
       }
     }
     return onUpdate;

package/Server/Services/ScheduledMaintenanceOwnerTeamService.ts

@@ -66,15 +66,17 @@ export class Service extends DatabaseService<Model> {
         });
 
         if (team && team.name) {
-          await ScheduledMaintenanceFeedService.createScheduledMaintenanceFeed({
-            scheduledMaintenanceId: scheduledMaintenanceId,
-            projectId: projectId,
-            scheduledMaintenanceFeedEventType:
-              ScheduledMaintenanceFeedEventType.OwnerTeamRemoved,
-            displayColor: Red500,
-            feedInfoInMarkdown: `**Team ${team.name}** was removed from the scheduled maintenance as the owner.`,
-            userId: deleteByUserId || undefined,
-          });
+          await ScheduledMaintenanceFeedService.createScheduledMaintenanceFeedItem(
+            {
+              scheduledMaintenanceId: scheduledMaintenanceId,
+              projectId: projectId,
+              scheduledMaintenanceFeedEventType:
+                ScheduledMaintenanceFeedEventType.OwnerTeamRemoved,
+              displayColor: Red500,
+              feedInfoInMarkdown: `Removed team **${team.name}** from the scheduled maintenance as the owner.`,
+              userId: deleteByUserId || undefined,
+            },
+          );
         }
       }
     }
@@ -107,15 +109,17 @@ export class Service extends DatabaseService<Model> {
       });
 
       if (team && team.name) {
-        await ScheduledMaintenanceFeedService.createScheduledMaintenanceFeed({
-          scheduledMaintenanceId: scheduledMaintenanceId,
-          projectId: projectId,
-          scheduledMaintenanceFeedEventType:
-            ScheduledMaintenanceFeedEventType.OwnerTeamAdded,
-          displayColor: Gray500,
-          feedInfoInMarkdown: `**Team ${team.name}** was added to the scheduled maintenance as the owner.`,
-          userId: createdByUserId || undefined,
-        });
+        await ScheduledMaintenanceFeedService.createScheduledMaintenanceFeedItem(
+          {
+            scheduledMaintenanceId: scheduledMaintenanceId,
+            projectId: projectId,
+            scheduledMaintenanceFeedEventType:
+              ScheduledMaintenanceFeedEventType.OwnerTeamAdded,
+            displayColor: Gray500,
+            feedInfoInMarkdown: `Added team **${team.name}** to the scheduled maintenance as the owner.`,
+            userId: createdByUserId || undefined,
+          },
+        );
       }
     }