@oneuptime/common 9.4.7 → 9.4.8

package/Server/Services/AlertEpisodeInternalNoteService.ts

@@ -0,0 +1,71 @@
+import ObjectID from "../../Types/ObjectID";
+import DatabaseService from "./DatabaseService";
+import Model from "../../Models/DatabaseModels/AlertEpisodeInternalNote";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import File from "../../Models/DatabaseModels/File";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+  }
+
+  @CaptureSpan()
+  public async addNote(data: {
+    userId: ObjectID;
+    alertEpisodeId: ObjectID;
+    projectId: ObjectID;
+    note: string;
+    attachmentFileIds?: Array<ObjectID>;
+    postedFromSlackMessageId?: string;
+  }): Promise<Model> {
+    const internalNote: Model = new Model();
+    internalNote.createdByUserId = data.userId;
+    internalNote.alertEpisodeId = data.alertEpisodeId;
+    internalNote.projectId = data.projectId;
+    internalNote.note = data.note;
+
+    if (data.postedFromSlackMessageId) {
+      internalNote.postedFromSlackMessageId = data.postedFromSlackMessageId;
+    }
+
+    if (data.attachmentFileIds && data.attachmentFileIds.length > 0) {
+      internalNote.attachments = data.attachmentFileIds.map(
+        (fileId: ObjectID) => {
+          const file: File = new File();
+          file.id = fileId;
+          return file;
+        },
+      );
+    }
+
+    return this.create({
+      data: internalNote,
+      props: {
+        isRoot: true,
+      },
+    });
+  }
+
+  @CaptureSpan()
+  public async hasNoteFromSlackMessage(data: {
+    alertEpisodeId: ObjectID;
+    postedFromSlackMessageId: string;
+  }): Promise<boolean> {
+    const existingNote: Model | null = await this.findOneBy({
+      query: {
+        alertEpisodeId: data.alertEpisodeId,
+        postedFromSlackMessageId: data.postedFromSlackMessageId,
+      },
+      select: {
+        _id: true,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    return existingNote !== null;
+  }
+}
+
+export default new Service();

package/Server/Services/AlertEpisodeMemberService.ts

@@ -0,0 +1,267 @@
+import CreateBy from "../Types/Database/CreateBy";
+import DeleteBy from "../Types/Database/DeleteBy";
+import { OnCreate, OnDelete } from "../Types/Database/Hooks";
+import DatabaseService from "./DatabaseService";
+import BadDataException from "../../Types/Exception/BadDataException";
+import ObjectID from "../../Types/ObjectID";
+import Model from "../../Models/DatabaseModels/AlertEpisodeMember";
+import Alert from "../../Models/DatabaseModels/Alert";
+import { IsBillingEnabled } from "../EnvironmentConfig";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import logger from "../Utils/Logger";
+import AlertEpisodeFeedService from "./AlertEpisodeFeedService";
+import { AlertEpisodeFeedEventType } from "../../Models/DatabaseModels/AlertEpisodeFeed";
+import { Yellow500, Green500 } from "../../Types/BrandColors";
+import OneUptimeDate from "../../Types/Date";
+import AlertService from "./AlertService";
+import AlertEpisodeService from "./AlertEpisodeService";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+    if (IsBillingEnabled) {
+      this.hardDeleteItemsOlderThanInDays("createdAt", 3 * 365); // 3 years
+    }
+  }
+
+  @CaptureSpan()
+  protected override async onBeforeCreate(
+    createBy: CreateBy<Model>,
+  ): Promise<OnCreate<Model>> {
+    if (!createBy.data.alertEpisodeId) {
+      throw new BadDataException("alertEpisodeId is required");
+    }
+
+    if (!createBy.data.alertId) {
+      throw new BadDataException("alertId is required");
+    }
+
+    // Check if this alert is already in the episode
+    const existingMember: Model | null = await this.findOneBy({
+      query: {
+        alertEpisodeId: createBy.data.alertEpisodeId,
+        alertId: createBy.data.alertId,
+      },
+      props: {
+        isRoot: true,
+      },
+      select: {
+        _id: true,
+      },
+    });
+
+    if (existingMember) {
+      throw new BadDataException("Alert is already a member of this episode");
+    }
+
+    // Set addedAt if not provided
+    if (!createBy.data.addedAt) {
+      createBy.data.addedAt = OneUptimeDate.getCurrentDate();
+    }
+
+    return { createBy, carryForward: null };
+  }
+
+  @CaptureSpan()
+  protected override async onCreateSuccess(
+    _onCreate: OnCreate<Model>,
+    createdItem: Model,
+  ): Promise<Model> {
+    if (!createdItem.alertEpisodeId) {
+      throw new BadDataException("alertEpisodeId is required");
+    }
+
+    if (!createdItem.alertId) {
+      throw new BadDataException("alertId is required");
+    }
+
+    if (!createdItem.projectId) {
+      throw new BadDataException("projectId is required");
+    }
+
+    // Update alert's episode reference
+    await AlertService.updateOneById({
+      id: createdItem.alertId,
+      data: {
+        alertEpisodeId: createdItem.alertEpisodeId,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    // Update episode's alertCount and lastAlertAddedAt
+    Promise.resolve()
+      .then(async () => {
+        try {
+          await AlertEpisodeService.updateAlertCount(
+            createdItem.alertEpisodeId!,
+          );
+          await AlertEpisodeService.updateLastAlertAddedAt(
+            createdItem.alertEpisodeId!,
+          );
+        } catch (error) {
+          logger.error(
+            `Error updating episode counts in AlertEpisodeMemberService.onCreateSuccess: ${error}`,
+          );
+        }
+      })
+      .catch((error: Error) => {
+        logger.error(
+          `Critical error in AlertEpisodeMemberService.onCreateSuccess: ${error}`,
+        );
+      });
+
+    // Get alert details for feed
+    const alert: Alert | null = await AlertService.findOneById({
+      id: createdItem.alertId,
+      select: {
+        alertNumber: true,
+        title: true,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    // Create feed item
+    await AlertEpisodeFeedService.createAlertEpisodeFeedItem({
+      alertEpisodeId: createdItem.alertEpisodeId,
+      projectId: createdItem.projectId,
+      alertEpisodeFeedEventType: AlertEpisodeFeedEventType.AlertAdded,
+      displayColor: Yellow500,
+      feedInfoInMarkdown: `**Alert #${alert?.alertNumber || "N/A"}** added to episode: ${alert?.title || "No title"}`,
+      userId: createdItem.addedByUserId || undefined,
+    });
+
+    return createdItem;
+  }
+
+  @CaptureSpan()
+  protected override async onBeforeDelete(
+    deleteBy: DeleteBy<Model>,
+  ): Promise<OnDelete<Model>> {
+    // Get the member records before deletion
+    const membersToDelete: Model[] = await this.findBy({
+      query: deleteBy.query,
+      props: {
+        isRoot: true,
+      },
+      select: {
+        alertEpisodeId: true,
+        alertId: true,
+        projectId: true,
+      },
+      limit: 100,
+      skip: 0,
+    });
+
+    return {
+      deleteBy,
+      carryForward: membersToDelete,
+    };
+  }
+
+  @CaptureSpan()
+  protected override async onDeleteSuccess(
+    onDelete: OnDelete<Model>,
+    _itemIdsBeforeDelete: ObjectID[],
+  ): Promise<OnDelete<Model>> {
+    const membersDeleted: Model[] = onDelete.carryForward as Model[];
+
+    if (membersDeleted && membersDeleted.length > 0) {
+      for (const member of membersDeleted) {
+        if (member.alertId) {
+          // Clear the episode reference from the alert
+          await AlertService.updateOneById({
+            id: member.alertId,
+            data: {
+              alertEpisodeId: undefined as any,
+            },
+            props: {
+              isRoot: true,
+            },
+          });
+
+          // Get alert details for feed
+          const alert: Alert | null = await AlertService.findOneById({
+            id: member.alertId,
+            select: {
+              alertNumber: true,
+              title: true,
+            },
+            props: {
+              isRoot: true,
+            },
+          });
+
+          // Create feed item for removal
+          if (member.alertEpisodeId && member.projectId) {
+            await AlertEpisodeFeedService.createAlertEpisodeFeedItem({
+              alertEpisodeId: member.alertEpisodeId,
+              projectId: member.projectId,
+              alertEpisodeFeedEventType: AlertEpisodeFeedEventType.AlertRemoved,
+              displayColor: Green500,
+              feedInfoInMarkdown: `**Alert #${alert?.alertNumber || "N/A"}** removed from episode: ${alert?.title || "No title"}`,
+            });
+          }
+        }
+
+        if (member.alertEpisodeId) {
+          // Update episode's alertCount
+          await AlertEpisodeService.updateAlertCount(member.alertEpisodeId);
+        }
+      }
+    }
+
+    return onDelete;
+  }
+
+  @CaptureSpan()
+  public async getAlertsInEpisode(episodeId: ObjectID): Promise<ObjectID[]> {
+    const members: Model[] = await this.findBy({
+      query: {
+        alertEpisodeId: episodeId,
+      },
+      props: {
+        isRoot: true,
+      },
+      select: {
+        alertId: true,
+      },
+      limit: 1000,
+      skip: 0,
+    });
+
+    return members
+      .filter((m: Model) => {
+        return m.alertId;
+      })
+      .map((m: Model) => {
+        return m.alertId!;
+      });
+  }
+
+  @CaptureSpan()
+  public async isAlertInEpisode(
+    alertId: ObjectID,
+    episodeId: ObjectID,
+  ): Promise<boolean> {
+    const member: Model | null = await this.findOneBy({
+      query: {
+        alertId: alertId,
+        alertEpisodeId: episodeId,
+      },
+      props: {
+        isRoot: true,
+      },
+      select: {
+        _id: true,
+      },
+    });
+
+    return member !== null;
+  }
+}
+
+export default new Service();

package/Server/Services/AlertEpisodeOwnerTeamService.ts

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

package/Server/Services/AlertEpisodeOwnerUserService.ts

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