@oneuptime/common 7.0.3517 → 7.0.3538

package/Server/Services/AlertFeedService.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, {
   AlertFeedEventType,
@@ -27,54 +28,60 @@ export class Service extends DatabaseService<Model> {
     displayColor?: Color | undefined;
     userId?: ObjectID | undefined;
     postedAt?: Date | undefined;
-  }): Promise<Model> {
-    if (!data.alertId) {
-      throw new BadDataException("Alert ID is required");
-    }
+  }): Promise<void> {
+    try {
+      if (!data.alertId) {
+        throw new BadDataException("Alert 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.alertFeedEventType) {
-      throw new BadDataException("Alert log event is required");
-    }
+      if (!data.alertFeedEventType) {
+        throw new BadDataException("Alert log event is required");
+      }
 
-    if (!data.projectId) {
-      throw new BadDataException("Project ID is required");
-    }
+      if (!data.projectId) {
+        throw new BadDataException("Project ID is required");
+      }
 
-    const alertFeed: Model = new Model();
+      const alertFeed: Model = new Model();
 
-    if (!data.displayColor) {
-      data.displayColor = Blue500;
-    }
+      if (!data.displayColor) {
+        data.displayColor = Blue500;
+      }
 
-    if (data.userId) {
-      alertFeed.userId = data.userId;
-    }
+      if (data.userId) {
+        alertFeed.userId = data.userId;
+      }
 
-    alertFeed.displayColor = data.displayColor;
+      alertFeed.displayColor = data.displayColor;
 
-    alertFeed.alertId = data.alertId;
-    alertFeed.feedInfoInMarkdown = data.feedInfoInMarkdown;
-    alertFeed.alertFeedEventType = data.alertFeedEventType;
-    alertFeed.projectId = data.projectId;
+      alertFeed.alertId = data.alertId;
+      alertFeed.feedInfoInMarkdown = data.feedInfoInMarkdown;
+      alertFeed.alertFeedEventType = data.alertFeedEventType;
+      alertFeed.projectId = data.projectId;
 
-    if (!data.postedAt) {
-      alertFeed.postedAt = OneUptimeDate.getCurrentDate();
-    }
+      if (!data.postedAt) {
+        alertFeed.postedAt = OneUptimeDate.getCurrentDate();
+      }
 
-    if (data.moreInformationInMarkdown) {
-      alertFeed.moreInformationInMarkdown = data.moreInformationInMarkdown;
-    }
+      if (data.moreInformationInMarkdown) {
+        alertFeed.moreInformationInMarkdown = data.moreInformationInMarkdown;
+      }
 
-    return await this.create({
-      data: alertFeed,
-      props: {
-        isRoot: true,
-      },
-    });
+      await this.create({
+        data: alertFeed,
+        props: {
+          isRoot: true,
+        },
+      });
+    } catch (error) {
+      logger.error("AlertFeedService.createAlertFeed");
+      logger.error(error);
+      // we dont want to throw the error here, as this is a non-critical operation
+    }
   }
 }
 

package/Server/Services/AlertInternalNoteService.ts

@@ -1,10 +1,83 @@
+import ObjectID from "../../Types/ObjectID";
 import DatabaseService from "./DatabaseService";
 import Model from "Common/Models/DatabaseModels/AlertInternalNote";
+import { OnCreate, OnUpdate } from "../Types/Database/Hooks";
+import AlertFeedService from "./AlertFeedService";
+import { AlertFeedEventType } from "../../Models/DatabaseModels/AlertFeed";
+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 AlertFeedService.createAlertFeed({
+      alertId: createdItem.alertId!,
+      projectId: createdItem.projectId!,
+      alertFeedEventType: AlertFeedEventType.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: {
+          alertId: 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 AlertFeedService.createAlertFeed({
+          alertId: updatedItem.alertId!,
+          projectId: updatedItem.projectId!,
+          alertFeedEventType: AlertFeedEventType.PrivateNote,
+          displayColor: Blue500,
+          userId: userId || undefined,
+
+          feedInfoInMarkdown: `**Updated Internal / Private Note**
+  
+  ${updatedItem.note}
+            `,
+        });
+      }
+    }
+    return onUpdate;
+  }
 }
 
 export default new Service();

package/Server/Services/AlertOwnerTeamService.ts

@@ -1,10 +1,122 @@
+import Team from "../../Models/DatabaseModels/Team";
+import ObjectID from "../../Types/ObjectID";
+import DeleteBy from "../Types/Database/DeleteBy";
+import { OnCreate, OnDelete } from "../Types/Database/Hooks";
 import DatabaseService from "./DatabaseService";
 import Model from "Common/Models/DatabaseModels/AlertOwnerTeam";
+import TeamService from "./TeamService";
+import AlertFeedService from "./AlertFeedService";
+import { AlertFeedEventType } from "../../Models/DatabaseModels/AlertFeed";
+import { Gray500, Red500 } from "../../Types/BrandColors";
 
 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: {
+        alertId: 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 alertId: ObjectID | undefined = item.alertId;
+      const projectId: ObjectID | undefined = item.projectId;
+      const teamId: ObjectID | undefined = item.teamId;
+
+      if (alertId && teamId && projectId) {
+        const team: Team | null = await TeamService.findOneById({
+          id: teamId,
+          select: {
+            name: true,
+          },
+          props: {
+            isRoot: true,
+          },
+        });
+
+        if (team && team.name) {
+          await AlertFeedService.createAlertFeed({
+            alertId: alertId,
+            projectId: projectId,
+            alertFeedEventType: AlertFeedEventType.OwnerTeamRemoved,
+            displayColor: Red500,
+            feedInfoInMarkdown: `**Team ${team.name}** was removed from the alert as the owner.`,
+            userId: deleteByUserId || undefined,
+          });
+        }
+      }
+    }
+
+    return onDelete;
+  }
+
+  public override async onCreateSuccess(
+    onCreate: OnCreate<Model>,
+    createdItem: Model,
+  ): Promise<Model> {
+    // add alert feed.
+
+    const alertId: ObjectID | undefined = createdItem.alertId;
+    const projectId: ObjectID | undefined = createdItem.projectId;
+    const teamId: ObjectID | undefined = createdItem.teamId;
+    const createdByUserId: ObjectID | undefined =
+      createdItem.createdByUserId || onCreate.createBy.props.userId;
+
+    if (alertId && teamId && projectId) {
+      const team: Team | null = await TeamService.findOneById({
+        id: teamId,
+        select: {
+          name: true,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+      if (team && team.name) {
+        await AlertFeedService.createAlertFeed({
+          alertId: alertId,
+          projectId: projectId,
+          alertFeedEventType: AlertFeedEventType.OwnerTeamAdded,
+          displayColor: Gray500,
+          feedInfoInMarkdown: `**Team ${team.name}** was added to the alert as the owner.`,
+          userId: createdByUserId || undefined,
+        });
+      }
+    }
+
+    return createdItem;
+  }
 }
 
 export default new Service();

package/Server/Services/AlertOwnerUserService.ts

@@ -1,10 +1,124 @@
+import User from "../../Models/DatabaseModels/User";
+import ObjectID from "../../Types/ObjectID";
+import DeleteBy from "../Types/Database/DeleteBy";
+import { OnCreate, OnDelete } from "../Types/Database/Hooks";
 import DatabaseService from "./DatabaseService";
 import Model from "Common/Models/DatabaseModels/AlertOwnerUser";
+import UserService from "./UserService";
+import AlertFeedService from "./AlertFeedService";
+import { AlertFeedEventType } from "../../Models/DatabaseModels/AlertFeed";
+import { Gray500, Red500 } from "../../Types/BrandColors";
 
 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: {
+        alertId: true,
+        projectId: true,
+        userId: 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 alertId: ObjectID | undefined = item.alertId;
+      const projectId: ObjectID | undefined = item.projectId;
+      const userId: ObjectID | undefined = item.userId;
+
+      if (alertId && userId && projectId) {
+        const user: User | null = await UserService.findOneById({
+          id: userId,
+          select: {
+            name: true,
+            email: true,
+          },
+          props: {
+            isRoot: true,
+          },
+        });
+
+        if (user && user.name) {
+          await AlertFeedService.createAlertFeed({
+            alertId: alertId,
+            projectId: projectId,
+            alertFeedEventType: AlertFeedEventType.OwnerUserRemoved,
+            displayColor: Red500,
+            feedInfoInMarkdown: `**${user.name.toString()}** (${user.email?.toString()}) was removed from the alert as the owner.`,
+            userId: deleteByUserId || undefined,
+          });
+        }
+      }
+    }
+
+    return onDelete;
+  }
+
+  public override async onCreateSuccess(
+    onCreate: OnCreate<Model>,
+    createdItem: Model,
+  ): Promise<Model> {
+    // add alert feed.
+
+    const alertId: ObjectID | undefined = createdItem.alertId;
+    const projectId: ObjectID | undefined = createdItem.projectId;
+    const userId: ObjectID | undefined = createdItem.userId;
+    const createdByUserId: ObjectID | undefined =
+      createdItem.createdByUserId || onCreate.createBy.props.userId;
+
+    if (alertId && userId && projectId) {
+      const user: User | null = await UserService.findOneById({
+        id: userId,
+        select: {
+          name: true,
+          email: true,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+      if (user && user.name) {
+        await AlertFeedService.createAlertFeed({
+          alertId: alertId,
+          projectId: projectId,
+          alertFeedEventType: AlertFeedEventType.OwnerUserAdded,
+          displayColor: Gray500,
+          feedInfoInMarkdown: `**${user.name.toString()}** (${user.email?.toString()}) was added to the alert as the owner.`,
+          userId: createdByUserId || undefined,
+        });
+      }
+    }
+
+    return createdItem;
+  }
 }
 
 export default new Service();

package/Server/Services/AlertService.ts

@@ -38,6 +38,9 @@ import Metric, {
   ServiceType,
 } from "../../Models/AnalyticsModels/Metric";
 import AlertMetricType from "../../Types/Alerts/AlertMetricType";
+import AlertFeedService from "./AlertFeedService";
+import { AlertFeedEventType } from "../../Models/DatabaseModels/AlertFeed";
+import { Gray500, Red500 } from "../../Types/BrandColors";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
@@ -224,6 +227,48 @@ export class Service extends DatabaseService<Model> {
       throw new BadDataException("currentAlertStateId is required");
     }
 
+    const createdByUserId: ObjectID | undefined | null =
+      createdItem.createdByUserId || createdItem.createdByUser?.id;
+
+    await AlertFeedService.createAlertFeed({
+      alertId: createdItem.id!,
+      projectId: createdItem.projectId!,
+      alertFeedEventType: AlertFeedEventType.AlertCreated,
+      displayColor: Red500,
+      feedInfoInMarkdown: `**Alert Created**: 
+          
+  **Alert Title**:
+  
+  ${createdItem.title || "No title provided."}
+  
+  **Description**:
+  
+  ${createdItem.description || "No description provided."}
+    
+          `,
+      userId: createdByUserId || undefined,
+    });
+
+    await AlertFeedService.createAlertFeed({
+      alertId: createdItem.id!,
+      projectId: createdItem.projectId!,
+      alertFeedEventType: AlertFeedEventType.RootCause,
+      displayColor: Red500,
+      feedInfoInMarkdown: `**Root Cause**
+        
+${createdItem.rootCause || "No root cause provided."}`,
+    });
+
+    await AlertFeedService.createAlertFeed({
+      alertId: createdItem.id!,
+      projectId: createdItem.projectId!,
+      alertFeedEventType: AlertFeedEventType.RemediationNotes,
+      displayColor: Red500,
+      feedInfoInMarkdown: `**Remediation Notes**
+        
+${createdItem.remediationNotes || "No remediation notes provided."}`,
+    });
+
     await this.changeAlertState({
       projectId: createdItem.projectId,
       alertId: createdItem.id,
@@ -445,6 +490,82 @@ export class Service extends DatabaseService<Model> {
       }
     }
 
+    if (updatedItemIds.length > 0) {
+      for (const alertId of updatedItemIds) {
+        if (onUpdate.updateBy.data.title) {
+          // add alert feed.
+          const createdByUserId: ObjectID | undefined | null =
+            onUpdate.updateBy.props.userId;
+
+          await AlertFeedService.createAlertFeed({
+            alertId: alertId,
+            projectId: onUpdate.updateBy.props.tenantId as ObjectID,
+            alertFeedEventType: AlertFeedEventType.AlertUpdated,
+            displayColor: Gray500,
+            feedInfoInMarkdown: `**Alert title was updated.** Here's the new title.
+    
+${onUpdate.updateBy.data.title || "No title provided."}
+              `,
+            userId: createdByUserId || undefined,
+          });
+        }
+
+        if (onUpdate.updateBy.data.rootCause) {
+          // add alert feed.
+          const createdByUserId: ObjectID | undefined | null =
+            onUpdate.updateBy.props.userId;
+
+          await AlertFeedService.createAlertFeed({
+            alertId: alertId,
+            projectId: onUpdate.updateBy.props.tenantId as ObjectID,
+            alertFeedEventType: AlertFeedEventType.AlertUpdated,
+            displayColor: Gray500,
+            feedInfoInMarkdown: `**Alert root cause was updated.** Here's the new root cause.
+          
+${onUpdate.updateBy.data.rootCause || "No root cause provided."}
+            `,
+            userId: createdByUserId || undefined,
+          });
+        }
+
+        if (onUpdate.updateBy.data.description) {
+          // add alert feed.
+          const createdByUserId: ObjectID | undefined | null =
+            onUpdate.updateBy.props.userId;
+
+          await AlertFeedService.createAlertFeed({
+            alertId: alertId,
+            projectId: onUpdate.updateBy.props.tenantId as ObjectID,
+            alertFeedEventType: AlertFeedEventType.AlertUpdated,
+            displayColor: Gray500,
+            feedInfoInMarkdown: `**Alert description was updated.** Here's the new description.
+          
+${onUpdate.updateBy.data.description || "No description provided."}
+            `,
+            userId: createdByUserId || undefined,
+          });
+        }
+
+        if (onUpdate.updateBy.data.remediationNotes) {
+          // add alert feed.
+          const createdByUserId: ObjectID | undefined | null =
+            onUpdate.updateBy.props.userId;
+
+          await AlertFeedService.createAlertFeed({
+            alertId: alertId,
+            projectId: onUpdate.updateBy.props.tenantId as ObjectID,
+            alertFeedEventType: AlertFeedEventType.AlertUpdated,
+            displayColor: Gray500,
+            feedInfoInMarkdown: `**Remediation notes were updated.** Here are the new notes.
+    
+${onUpdate.updateBy.data.remediationNotes || "No remediation notes provided."}
+                `,
+            userId: createdByUserId || undefined,
+          });
+        }
+      }
+    }
+
     return onUpdate;
   }
 

package/Server/Services/AlertStateTimelineService.ts

@@ -19,6 +19,8 @@ import { JSONObject } from "../../Types/JSON";
 import AlertInternalNote from "../../Models/DatabaseModels/AlertInternalNote";
 import AlertInternalNoteService from "./AlertInternalNoteService";
 import logger from "../Utils/Logger";
+import AlertFeedService from "./AlertFeedService";
+import { AlertFeedEventType } from "../../Models/DatabaseModels/AlertFeed";
 
 export class Service extends DatabaseService<AlertStateTimeline> {
   public constructor() {
@@ -130,10 +132,15 @@ export class Service extends DatabaseService<AlertStateTimeline> {
       });
     }
 
+    const privateNote: string | undefined = (
+      createBy.miscDataProps as JSONObject | undefined
+    )?.["privateNote"] as string | undefined;
+
     return {
       createBy,
       carryForward: {
         lastAlertStateTimelineId: lastAlertStateTimeline?.id || null,
+        privateNote: privateNote,
       },
     };
   }
@@ -164,6 +171,36 @@ export class Service extends DatabaseService<AlertStateTimeline> {
       });
     }
 
+    const alertState: AlertState | null = await AlertStateService.findOneBy({
+      query: {
+        _id: createdItem.alertStateId.toString()!,
+      },
+      props: {
+        isRoot: true,
+      },
+      select: {
+        _id: true,
+        isResolvedState: true,
+        isAcknowledgedState: true,
+        isCreatedState: true,
+        color: true,
+        name: true,
+      },
+    });
+
+    const stateName: string = alertState?.name || "";
+
+    await AlertFeedService.createAlertFeed({
+      alertId: createdItem.alertId!,
+      projectId: createdItem.projectId!,
+      alertFeedEventType: AlertFeedEventType.AlertStateChanged,
+      displayColor: alertState?.color,
+      feedInfoInMarkdown: "**Alert State** changed to **" + stateName + "**",
+      moreInformationInMarkdown: `**Cause:** 
+${createdItem.rootCause}`,
+      userId: createdItem.createdByUserId || onCreate.createBy.props.userId,
+    });
+
     await AlertService.updateOneBy({
       query: {
         _id: createdItem.alertId?.toString(),
@@ -174,6 +211,21 @@ export class Service extends DatabaseService<AlertStateTimeline> {
       props: onCreate.createBy.props,
     });
 
+    if (onCreate.carryForward.privateNote) {
+      const privateNote: string = onCreate.carryForward.privateNote;
+
+      const alertInternalNote: AlertInternalNote = new AlertInternalNote();
+      alertInternalNote.alertId = createdItem.alertId;
+      alertInternalNote.note = privateNote;
+      alertInternalNote.createdAt = createdItem.startsAt!;
+      alertInternalNote.projectId = createdItem.projectId!;
+
+      await AlertInternalNoteService.create({
+        data: alertInternalNote,
+        props: onCreate.createBy.props,
+      });
+    }
+
     AlertService.refreshAlertMetrics({
       alertId: createdItem.alertId,
     }).catch((error: Error) => {