@oneuptime/common 7.0.3517 → 7.0.3538

package/Server/Services/OnCallDutyPolicyExecutionLogService.ts

@@ -14,6 +14,9 @@ import OnCallDutyPolicy from "../../Models/DatabaseModels/OnCallDutyPolicy";
 import OnCallDutyPolicyService from "./OnCallDutyPolicyService";
 import ObjectID from "../../Types/ObjectID";
 import Color from "../../Types/Color";
+import AlertFeedService from "./AlertFeedService";
+import { AlertFeedEventType } from "../../Models/DatabaseModels/AlertFeed";
+import BadDataException from "../../Types/Exception/BadDataException";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
@@ -39,7 +42,7 @@ export class Service extends DatabaseService<Model> {
     _onCreate: OnCreate<Model>,
     createdItem: Model,
   ): Promise<Model> {
-    if (createdItem.triggeredByIncidentId) {
+    if (createdItem.triggeredByIncidentId || createdItem.triggeredByAlertId) {
       const onCallPolicy: OnCallDutyPolicy | null =
         await OnCallDutyPolicyService.findOneById({
           id: createdItem.onCallDutyPolicyId!,
@@ -54,13 +57,31 @@ export class Service extends DatabaseService<Model> {
         });
 
       if (onCallPolicy && onCallPolicy.id) {
-        await IncidentFeedService.createIncidentFeed({
-          incidentId: createdItem.triggeredByIncidentId,
-          projectId: createdItem.projectId!,
-          incidentFeedEventType: IncidentFeedEventType.OnCallPolicy,
-          displayColor: Yellow500,
-          feedInfoInMarkdown: `**On Call Policy Started Executing:** On Call Policy **${onCallPolicy.name}** started executing. Users on call on this policy will now be notified.`,
-        });
+        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.`;
+
+        if (
+          onCallPolicy &&
+          onCallPolicy.id &&
+          createdItem.triggeredByIncidentId
+        ) {
+          await IncidentFeedService.createIncidentFeed({
+            incidentId: createdItem.triggeredByIncidentId,
+            projectId: createdItem.projectId!,
+            incidentFeedEventType: IncidentFeedEventType.OnCallPolicy,
+            displayColor: Yellow500,
+            feedInfoInMarkdown: feedInfoInMarkdown,
+          });
+        }
+
+        if (onCallPolicy && onCallPolicy.id && createdItem.triggeredByAlertId) {
+          await AlertFeedService.createAlertFeed({
+            alertId: createdItem.triggeredByAlertId,
+            projectId: createdItem.projectId!,
+            alertFeedEventType: AlertFeedEventType.OnCallPolicy,
+            displayColor: Yellow500,
+            feedInfoInMarkdown: feedInfoInMarkdown,
+          });
+        }
       }
     }
 
@@ -92,12 +113,27 @@ export class Service extends DatabaseService<Model> {
         },
       });
 
+      let userNotificationEventType: UserNotificationEventType | null = null;
+
+      if (createdItem.triggeredByIncidentId) {
+        userNotificationEventType = UserNotificationEventType.IncidentCreated;
+      }
+
+      if (createdItem.triggeredByAlertId) {
+        userNotificationEventType = UserNotificationEventType.AlertCreated;
+      }
+
+      if (!userNotificationEventType) {
+        throw new BadDataException("Invalid userNotificationEventType");
+      }
+
       await OnCallDutyPolicyEscalationRuleService.startRuleExecution(
         executionRule.id!,
         {
           projectId: createdItem.projectId!,
           triggeredByIncidentId: createdItem.triggeredByIncidentId,
-          userNotificationEventType: UserNotificationEventType.IncidentCreated,
+          triggeredByAlertId: createdItem.triggeredByAlertId,
+          userNotificationEventType: userNotificationEventType,
           onCallPolicyExecutionLogId: createdItem.id!,
           onCallPolicyId: createdItem.onCallDutyPolicyId!,
         },
@@ -107,7 +143,7 @@ export class Service extends DatabaseService<Model> {
         id: createdItem.id!,
         data: {
           status: OnCallDutyPolicyStatus.Executing,
-          statusMessage: "First escalation rule executed....",
+          statusMessage: "First escalation rule executed...",
         },
         props: {
           isRoot: true,
@@ -165,6 +201,7 @@ export class Service extends DatabaseService<Model> {
             status: true,
             statusMessage: true,
             triggeredByIncidentId: true,
+            triggeredByAlertId: true,
           },
           props: {
             isRoot: true,
@@ -174,7 +211,8 @@ export class Service extends DatabaseService<Model> {
 
       if (
         onCalldutyPolicyExecutionLog &&
-        onCalldutyPolicyExecutionLog.triggeredByIncidentId
+        (onCalldutyPolicyExecutionLog.triggeredByIncidentId ||
+          onCalldutyPolicyExecutionLog.triggeredByAlertId)
       ) {
         const onCallPolicy: OnCallDutyPolicy | null =
           await OnCallDutyPolicyService.findOneById({
@@ -190,22 +228,43 @@ export class Service extends DatabaseService<Model> {
           });
 
         if (onCallPolicy && onCallPolicy.id) {
-          await IncidentFeedService.createIncidentFeed({
-            incidentId: onCalldutyPolicyExecutionLog.triggeredByIncidentId,
-            projectId: onCalldutyPolicyExecutionLog.projectId!,
-            incidentFeedEventType: IncidentFeedEventType.OnCallPolicy,
-            displayColor: onCalldutyPolicyExecutionLog.status
-              ? this.getDisplayColorByStatus(
-                  onCalldutyPolicyExecutionLog.status,
-                )
-              : Blue500,
-            moreInformationInMarkdown: `**Status:** ${onCalldutyPolicyExecutionLog.status}
-            
-**Message:** ${onCalldutyPolicyExecutionLog.statusMessage}`,
-            feedInfoInMarkdown: `**On Call Policy Status Updated:** 
-
-On-call policy **${onCallPolicy.name}** status updated to **${onCalldutyPolicyExecutionLog.status}**`,
-          });
+          const moreInformationInMarkdown: string = `**Status:** ${onCalldutyPolicyExecutionLog.status}
+
+**Message:** ${onCalldutyPolicyExecutionLog.statusMessage}`;
+
+          const feedInfoInMarkdown: string = `**On Call Policy Status Updated:**
+
+On-call policy **${onCallPolicy.name}** status updated to **${onCalldutyPolicyExecutionLog.status}**`;
+
+          if (onCalldutyPolicyExecutionLog.triggeredByIncidentId) {
+            await IncidentFeedService.createIncidentFeed({
+              incidentId: onCalldutyPolicyExecutionLog.triggeredByIncidentId,
+              projectId: onCalldutyPolicyExecutionLog.projectId!,
+              incidentFeedEventType: IncidentFeedEventType.OnCallPolicy,
+              displayColor: onCalldutyPolicyExecutionLog.status
+                ? this.getDisplayColorByStatus(
+                    onCalldutyPolicyExecutionLog.status,
+                  )
+                : Blue500,
+              moreInformationInMarkdown: moreInformationInMarkdown,
+              feedInfoInMarkdown: feedInfoInMarkdown,
+            });
+          }
+
+          if (onCalldutyPolicyExecutionLog.triggeredByAlertId) {
+            await AlertFeedService.createAlertFeed({
+              alertId: onCalldutyPolicyExecutionLog.triggeredByAlertId,
+              projectId: onCalldutyPolicyExecutionLog.projectId!,
+              alertFeedEventType: AlertFeedEventType.OnCallPolicy,
+              displayColor: onCalldutyPolicyExecutionLog.status
+                ? this.getDisplayColorByStatus(
+                    onCalldutyPolicyExecutionLog.status,
+                  )
+                : Blue500,
+              moreInformationInMarkdown: moreInformationInMarkdown,
+              feedInfoInMarkdown: feedInfoInMarkdown,
+            });
+          }
         }
       }
     }

package/Server/Services/OnCallDutyPolicyExecutionLogTimelineService.ts

@@ -9,6 +9,8 @@ import Color from "../../Types/Color";
 import ObjectID from "../../Types/ObjectID";
 import logger from "../Utils/Logger";
 import { LIMIT_PER_PROJECT } from "../../Types/Database/LimitMax";
+import AlertFeedService from "./AlertFeedService";
+import { AlertFeedEventType } from "../../Models/DatabaseModels/AlertFeed";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
@@ -36,7 +38,7 @@ export class Service extends DatabaseService<Model> {
     }
   }
 
-  public async addToIncidentFeed(data: {
+  public async addToIncidentOrAlertFeed(data: {
     onCallDutyPolicyExecutionLogTimelineId: ObjectID;
   }): Promise<void> {
     logger.debug(
@@ -50,6 +52,7 @@ export class Service extends DatabaseService<Model> {
           _id: true,
           onCallDutyPolicyId: true,
           triggeredByIncidentId: true,
+          triggeredByAlertId: true,
           projectId: true,
           status: true,
           statusMessage: true,
@@ -89,7 +92,10 @@ export class Service extends DatabaseService<Model> {
       return;
     }
 
-    if (!onCallDutyPolicyExecutionLogTimeline.triggeredByIncidentId) {
+    if (
+      !onCallDutyPolicyExecutionLogTimeline.triggeredByIncidentId &&
+      !onCallDutyPolicyExecutionLogTimeline.triggeredByAlertId
+    ) {
       return;
     }
 
@@ -120,14 +126,26 @@ The on-call policy **${onCallDutyPolicyExecutionLogTimeline.onCallDutyPolicy.nam
 
         logger.debug("Feed Info in Markdown: " + feedInfoInMarkdown);
 
-        await IncidentFeedService.createIncidentFeed({
-          incidentId:
-            onCallDutyPolicyExecutionLogTimeline.triggeredByIncidentId,
-          projectId: onCallDutyPolicyExecutionLogTimeline.projectId!,
-          incidentFeedEventType: IncidentFeedEventType.OnCallPolicy,
-          displayColor: displayColor,
-          feedInfoInMarkdown: feedInfoInMarkdown,
-        });
+        if (onCallDutyPolicyExecutionLogTimeline.triggeredByIncidentId) {
+          await IncidentFeedService.createIncidentFeed({
+            incidentId:
+              onCallDutyPolicyExecutionLogTimeline.triggeredByIncidentId,
+            projectId: onCallDutyPolicyExecutionLogTimeline.projectId!,
+            incidentFeedEventType: IncidentFeedEventType.OnCallPolicy,
+            displayColor: displayColor,
+            feedInfoInMarkdown: feedInfoInMarkdown,
+          });
+        }
+
+        if (onCallDutyPolicyExecutionLogTimeline.triggeredByAlertId) {
+          await AlertFeedService.createAlertFeed({
+            alertId: onCallDutyPolicyExecutionLogTimeline.triggeredByAlertId,
+            projectId: onCallDutyPolicyExecutionLogTimeline.projectId!,
+            alertFeedEventType: AlertFeedEventType.OnCallPolicy,
+            displayColor: displayColor,
+            feedInfoInMarkdown: feedInfoInMarkdown,
+          });
+        }
 
         logger.debug("Incident Feed created");
       }
@@ -141,7 +159,7 @@ The on-call policy **${onCallDutyPolicyExecutionLogTimeline.onCallDutyPolicy.nam
     logger.debug("OnCallDutyPolicyExecutionLogTimelineService.onCreateSuccess");
     logger.debug(createdItem);
 
-    await this.addToIncidentFeed({
+    await this.addToIncidentOrAlertFeed({
       onCallDutyPolicyExecutionLogTimelineId: createdItem.id!,
     });
 
@@ -166,7 +184,7 @@ The on-call policy **${onCallDutyPolicyExecutionLogTimeline.onCallDutyPolicy.nam
       });
 
       for (const updatedItem of updatedItems) {
-        await this.addToIncidentFeed({
+        await this.addToIncidentOrAlertFeed({
           onCallDutyPolicyExecutionLogTimelineId: updatedItem.id as ObjectID,
         });
       }

package/Server/Services/ScheduledMaintenanceFeedService.ts

@@ -4,6 +4,7 @@ import OneUptimeDate from "../../Types/Date";
 import BadDataException from "../../Types/Exception/BadDataException";
 import ObjectID from "../../Types/ObjectID";
 import { IsBillingEnabled } from "../EnvironmentConfig";
+import logger from "../Utils/Logger";
 import DatabaseService from "./DatabaseService";
 import Model, {
   ScheduledMaintenanceFeedEventType,
@@ -27,56 +28,66 @@ export class Service extends DatabaseService<Model> {
     displayColor?: Color | undefined;
     userId?: ObjectID | undefined;
     postedAt?: Date | undefined;
-  }): Promise<Model> {
-    if (!data.scheduledMaintenanceId) {
-      throw new BadDataException("Scheduled Maintenance ID is required");
-    }
+  }): Promise<void> {
+    try {
+      if (!data.scheduledMaintenanceId) {
+        throw new BadDataException("Scheduled Maintenance ID is required");
+      }
 
-    if (!data.feedInfoInMarkdown) {
-      throw new BadDataException("Log in markdown is required");
-    }
+      if (!data.feedInfoInMarkdown) {
+        throw new BadDataException("Log in markdown is required");
+      }
 
-    if (!data.scheduledMaintenanceFeedEventType) {
-      throw new BadDataException("Scheduled Maintenance log event is required");
-    }
+      if (!data.scheduledMaintenanceFeedEventType) {
+        throw new BadDataException(
+          "Scheduled Maintenance log event is required",
+        );
+      }
 
-    if (!data.projectId) {
-      throw new BadDataException("Project ID is required");
-    }
+      if (!data.projectId) {
+        throw new BadDataException("Project ID is required");
+      }
 
-    if (!data.displayColor) {
-      data.displayColor = Blue500;
-    }
+      if (!data.displayColor) {
+        data.displayColor = Blue500;
+      }
 
-    const scheduledMaintenanceFeed: Model = new Model();
+      const scheduledMaintenanceFeed: Model = new Model();
 
-    scheduledMaintenanceFeed.displayColor = data.displayColor;
-    scheduledMaintenanceFeed.scheduledMaintenanceId =
-      data.scheduledMaintenanceId;
-    scheduledMaintenanceFeed.feedInfoInMarkdown = data.feedInfoInMarkdown;
-    scheduledMaintenanceFeed.scheduledMaintenanceFeedEventType =
-      data.scheduledMaintenanceFeedEventType;
-    scheduledMaintenanceFeed.projectId = data.projectId;
+      scheduledMaintenanceFeed.displayColor = data.displayColor;
+      scheduledMaintenanceFeed.scheduledMaintenanceId =
+        data.scheduledMaintenanceId;
+      scheduledMaintenanceFeed.feedInfoInMarkdown = data.feedInfoInMarkdown;
+      scheduledMaintenanceFeed.scheduledMaintenanceFeedEventType =
+        data.scheduledMaintenanceFeedEventType;
+      scheduledMaintenanceFeed.projectId = data.projectId;
 
-    if (data.userId) {
-      scheduledMaintenanceFeed.userId = data.userId;
-    }
+      if (data.userId) {
+        scheduledMaintenanceFeed.userId = data.userId;
+      }
 
-    if (data.moreInformationInMarkdown) {
-      scheduledMaintenanceFeed.moreInformationInMarkdown =
-        data.moreInformationInMarkdown;
-    }
+      if (data.moreInformationInMarkdown) {
+        scheduledMaintenanceFeed.moreInformationInMarkdown =
+          data.moreInformationInMarkdown;
+      }
 
-    if (!data.postedAt) {
-      scheduledMaintenanceFeed.postedAt = OneUptimeDate.getCurrentDate();
-    }
+      if (!data.postedAt) {
+        scheduledMaintenanceFeed.postedAt = OneUptimeDate.getCurrentDate();
+      }
 
-    return await this.create({
-      data: scheduledMaintenanceFeed,
-      props: {
-        isRoot: true,
-      },
-    });
+      await this.create({
+        data: scheduledMaintenanceFeed,
+        props: {
+          isRoot: true,
+        },
+      });
+    } catch (error) {
+      logger.error(
+        "ScheduledMaintenanceFeedService.createScheduledMaintenanceFeed",
+      );
+      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

@@ -1,10 +1,85 @@
+import ObjectID from "../../Types/ObjectID";
+import { OnCreate, OnUpdate } from "../Types/Database/Hooks";
 import DatabaseService from "./DatabaseService";
 import Model from "Common/Models/DatabaseModels/ScheduledMaintenanceInternalNote";
+import ScheduledMaintenanceFeedService from "./ScheduledMaintenanceFeedService";
+import { ScheduledMaintenanceFeedEventType } from "../../Models/DatabaseModels/ScheduledMaintenanceFeed";
+import { Blue500 } from "../../Types/BrandColors";
+import { LIMIT_PER_PROJECT } from "../../Types/Database/LimitMax";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
     super(Model);
   }
+
+  public override async onCreateSuccess(
+    _onCreate: OnCreate<Model>,
+    createdItem: Model,
+  ): Promise<Model> {
+    const userId: ObjectID | null | undefined =
+      createdItem.createdByUserId || createdItem.createdByUser?.id;
+
+    await ScheduledMaintenanceFeedService.createScheduledMaintenanceFeed({
+      scheduledMaintenanceId: createdItem.scheduledMaintenanceId!,
+      projectId: createdItem.projectId!,
+      scheduledMaintenanceFeedEventType:
+        ScheduledMaintenanceFeedEventType.PrivateNote,
+      displayColor: Blue500,
+      userId: userId || undefined,
+
+      feedInfoInMarkdown: `**Posted Internal / Private Note**
+  
+${createdItem.note}
+            `,
+    });
+
+    return createdItem;
+  }
+
+  public override async onUpdateSuccess(
+    onUpdate: OnUpdate<Model>,
+    _updatedItemIds: Array<ObjectID>,
+  ): Promise<OnUpdate<Model>> {
+    if (onUpdate.updateBy.data.note) {
+      const updatedItems: Array<Model> = await this.findBy({
+        query: onUpdate.updateBy.query,
+        limit: LIMIT_PER_PROJECT,
+        skip: 0,
+        props: {
+          isRoot: true,
+        },
+        select: {
+          scheduledMaintenanceId: true,
+          projectId: true,
+          note: true,
+          createdByUserId: true,
+          createdByUser: {
+            _id: true,
+          },
+        },
+      });
+
+      const userId: ObjectID | null | undefined =
+        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,
+
+          feedInfoInMarkdown: `**Updated Private Note**
+      
+${updatedItem.note}
+                `,
+        });
+      }
+    }
+    return onUpdate;
+  }
 }
 
 export default new Service();

package/Server/Services/ScheduledMaintenanceOwnerTeamService.ts

@@ -1,10 +1,126 @@
+import Team from "../../Models/DatabaseModels/Team";
+import ObjectID from "../../Types/ObjectID";
 import DatabaseService from "./DatabaseService";
 import Model from "Common/Models/DatabaseModels/ScheduledMaintenanceOwnerTeam";
+import TeamService from "./TeamService";
+import ScheduledMaintenanceFeedService from "./ScheduledMaintenanceFeedService";
+import { ScheduledMaintenanceFeedEventType } from "../../Models/DatabaseModels/ScheduledMaintenanceFeed";
+import { Gray500, Red500 } from "../../Types/BrandColors";
+import { OnCreate, OnDelete } from "../Types/Database/Hooks";
+import DeleteBy from "../Types/Database/DeleteBy";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
     super(Model);
   }
+
+  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: {
+        scheduledMaintenanceId: true,
+        projectId: true,
+        teamId: true,
+      },
+    });
+
+    return {
+      carryForward: {
+        itemsToDelete: itemsToDelete,
+      },
+      deleteBy: deleteBy,
+    };
+  }
+
+  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 scheduledMaintenanceId: ObjectID | undefined =
+        item.scheduledMaintenanceId;
+      const projectId: ObjectID | undefined = item.projectId;
+      const teamId: ObjectID | undefined = item.teamId;
+
+      if (scheduledMaintenanceId && teamId && projectId) {
+        const team: Team | null = await TeamService.findOneById({
+          id: teamId,
+          select: {
+            name: true,
+          },
+          props: {
+            isRoot: true,
+          },
+        });
+
+        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,
+          });
+        }
+      }
+    }
+
+    return onDelete;
+  }
+
+  public override async onCreateSuccess(
+    onCreate: OnCreate<Model>,
+    createdItem: Model,
+  ): Promise<Model> {
+    // add scheduledMaintenance feed.
+
+    const scheduledMaintenanceId: ObjectID | undefined =
+      createdItem.scheduledMaintenanceId;
+    const projectId: ObjectID | undefined = createdItem.projectId;
+    const teamId: ObjectID | undefined = createdItem.teamId;
+    const createdByUserId: ObjectID | undefined =
+      createdItem.createdByUserId || onCreate.createBy.props.userId;
+
+    if (scheduledMaintenanceId && teamId && projectId) {
+      const team: Team | null = await TeamService.findOneById({
+        id: teamId,
+        select: {
+          name: true,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+      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,
+        });
+      }
+    }
+
+    return createdItem;
+  }
 }
 
 export default new Service();