@oneuptime/common 9.5.2 → 9.5.4

package/Server/Services/AlertInternalNoteService.ts

@@ -85,7 +85,10 @@ export class Service extends DatabaseService<Model> {
 
     const alertId: ObjectID = createdItem.alertId!;
 
-    const alertNumber: number | null = await AlertService.getAlertNumber({
+    const alertNumberResult: {
+      number: number | null;
+      numberWithPrefix: string | null;
+    } = await AlertService.getAlertNumber({
       alertId: alertId,
     });
 
@@ -101,7 +104,7 @@ export class Service extends DatabaseService<Model> {
       displayColor: Blue500,
       userId: userId || undefined,
 
-      feedInfoInMarkdown: `📄 posted **private note** for this [Alert ${alertNumber}](${(await AlertService.getAlertLinkInDashboard(createdItem.projectId!, alertId)).toString()}):
+      feedInfoInMarkdown: `📄 posted **private note** for this [Alert ${alertNumberResult.numberWithPrefix || "#" + alertNumberResult.number}](${(await AlertService.getAlertLinkInDashboard(createdItem.projectId!, alertId)).toString()}):
       
 ${(createdItem.note || "") + attachmentsMarkdown}
                 `,

package/Server/Services/AlertOwnerTeamService.ts

@@ -73,7 +73,10 @@ export class Service extends DatabaseService<Model> {
         });
 
         if (team && team.name) {
-          const alertNumber: number | null = await AlertService.getAlertNumber({
+          const alertNumberResult: {
+            number: number | null;
+            numberWithPrefix: string | null;
+          } = await AlertService.getAlertNumber({
             alertId: alertId,
           });
           await AlertFeedService.createAlertFeedItem({
@@ -81,7 +84,7 @@ export class Service extends DatabaseService<Model> {
             projectId: projectId,
             alertFeedEventType: AlertFeedEventType.OwnerTeamRemoved,
             displayColor: Red500,
-            feedInfoInMarkdown: `👨🏻‍👩🏻‍👦🏻 Removed team **${team.name}** from the [Alert ${alertNumber}](${(await AlertService.getAlertLinkInDashboard(projectId!, alertId!)).toString()}) as the owner.`,
+            feedInfoInMarkdown: `👨🏻‍👩🏻‍👦🏻 Removed team **${team.name}** from the [Alert ${alertNumberResult.numberWithPrefix || "#" + alertNumberResult.number}](${(await AlertService.getAlertLinkInDashboard(projectId!, alertId!)).toString()}) as the owner.`,
             userId: deleteByUserId || undefined,
             workspaceNotification: {
               sendWorkspaceNotification: true,
@@ -120,7 +123,10 @@ export class Service extends DatabaseService<Model> {
       });
 
       if (team && team.name) {
-        const alertNumber: number | null = await AlertService.getAlertNumber({
+        const alertNumberResult: {
+          number: number | null;
+          numberWithPrefix: string | null;
+        } = await AlertService.getAlertNumber({
           alertId: alertId,
         });
 
@@ -129,7 +135,7 @@ export class Service extends DatabaseService<Model> {
           projectId: projectId,
           alertFeedEventType: AlertFeedEventType.OwnerTeamAdded,
           displayColor: Gray500,
-          feedInfoInMarkdown: `👨🏻‍👩🏻‍👦🏻 Added team **${team.name}** to the [Alert ${alertNumber}](${(await AlertService.getAlertLinkInDashboard(projectId!, alertId!)).toString()}) as the owner.`,
+          feedInfoInMarkdown: `👨🏻‍👩🏻‍👦🏻 Added team **${team.name}** to the [Alert ${alertNumberResult.numberWithPrefix || "#" + alertNumberResult.number}](${(await AlertService.getAlertLinkInDashboard(projectId!, alertId!)).toString()}) as the owner.`,
           userId: createdByUserId || undefined,
           workspaceNotification: {
             sendWorkspaceNotification: true,

package/Server/Services/AlertOwnerUserService.ts

@@ -74,7 +74,10 @@ export class Service extends DatabaseService<Model> {
         });
 
         if (user && user.name) {
-          const alertNumber: number | null = await AlertService.getAlertNumber({
+          const alertNumberResult: {
+            number: number | null;
+            numberWithPrefix: string | null;
+          } = await AlertService.getAlertNumber({
             alertId: alertId,
           });
 
@@ -83,7 +86,7 @@ export class Service extends DatabaseService<Model> {
             projectId: projectId,
             alertFeedEventType: AlertFeedEventType.OwnerUserRemoved,
             displayColor: Red500,
-            feedInfoInMarkdown: `👨🏻‍💻 Removed **${user.name.toString()}** (${user.email?.toString()}) from the [Alert ${alertNumber}](${(await AlertService.getAlertLinkInDashboard(projectId!, alertId!)).toString()}) as the owner.`,
+            feedInfoInMarkdown: `👨🏻‍💻 Removed **${user.name.toString()}** (${user.email?.toString()}) from the [Alert ${alertNumberResult.numberWithPrefix || "#" + alertNumberResult.number}](${(await AlertService.getAlertLinkInDashboard(projectId!, alertId!)).toString()}) as the owner.`,
             userId: deleteByUserId || undefined,
             workspaceNotification: {
               sendWorkspaceNotification: true,
@@ -123,7 +126,10 @@ export class Service extends DatabaseService<Model> {
       });
 
       if (user && user.name) {
-        const alertNumber: number | null = await AlertService.getAlertNumber({
+        const alertNumberResult: {
+          number: number | null;
+          numberWithPrefix: string | null;
+        } = await AlertService.getAlertNumber({
           alertId: alertId,
         });
         await AlertFeedService.createAlertFeedItem({
@@ -136,7 +142,7 @@ export class Service extends DatabaseService<Model> {
               userId: userId,
               projectId: projectId,
             },
-          )}** to the [Alert ${alertNumber}](${(await AlertService.getAlertLinkInDashboard(projectId!, alertId!)).toString()}) as the owner.`,
+          )}** to the [Alert ${alertNumberResult.numberWithPrefix || "#" + alertNumberResult.number}](${(await AlertService.getAlertLinkInDashboard(projectId!, alertId!)).toString()}) as the owner.`,
           userId: createdByUserId || undefined,
           workspaceNotification: {
             sendWorkspaceNotification: true,

package/Server/Services/AlertService.ts

@@ -55,6 +55,7 @@ import MetricType from "../../Models/DatabaseModels/MetricType";
 import Dictionary from "../../Types/Dictionary";
 import OnCallDutyPolicy from "../../Models/DatabaseModels/OnCallDutyPolicy";
 import AlertGroupingEngineService from "./AlertGroupingEngineService";
+import ProjectService from "./ProjectService";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
@@ -109,33 +110,6 @@ export class Service extends DatabaseService<Model> {
     return false;
   }
 
-  @CaptureSpan()
-  public async getExistingAlertNumberForProject(data: {
-    projectId: ObjectID;
-  }): Promise<number> {
-    // get last alert number.
-    const lastAlert: Model | null = await this.findOneBy({
-      query: {
-        projectId: data.projectId,
-      },
-      select: {
-        alertNumber: true,
-      },
-      sort: {
-        createdAt: SortOrder.Descending,
-      },
-      props: {
-        isRoot: true,
-      },
-    });
-
-    if (!lastAlert) {
-      return 0;
-    }
-
-    return lastAlert.alertNumber ? Number(lastAlert.alertNumber) : 0;
-  }
-
   @CaptureSpan()
   public async acknowledgeAlert(
     alertId: ObjectID,
@@ -220,12 +194,15 @@ export class Service extends DatabaseService<Model> {
 
     createBy.data.currentAlertStateId = alertState.id;
 
-    const alertNumberForThisAlert: number =
-      (await this.getExistingAlertNumberForProject({
-        projectId: projectId,
-      })) + 1;
+    const alertCounterResult: {
+      counter: number;
+      prefix: string | undefined;
+    } = await ProjectService.incrementAndGetAlertCounter(projectId);
 
-    createBy.data.alertNumber = alertNumberForThisAlert;
+    createBy.data.alertNumber = alertCounterResult.counter;
+    createBy.data.alertNumberWithPrefix = alertCounterResult.prefix
+      ? `${alertCounterResult.prefix}${alertCounterResult.counter}`
+      : `#${alertCounterResult.counter}`;
 
     if (
       (createBy.data.createdByUserId ||
@@ -424,6 +401,7 @@ export class Service extends DatabaseService<Model> {
         select: {
           projectId: true,
           alertNumber: true,
+          alertNumberWithPrefix: true,
           title: true,
           description: true,
           alertSeverity: {
@@ -460,7 +438,7 @@ export class Service extends DatabaseService<Model> {
       const createdByUserId: ObjectID | undefined | null =
         alert.createdByUserId || alert.createdByUser?.id;
 
-      let feedInfoInMarkdown: string = `#### 🚨 Alert ${alert.alertNumber?.toString()} Created: 
+      let feedInfoInMarkdown: string = `#### 🚨 Alert ${alert.alertNumberWithPrefix || "#" + alert.alertNumber?.toString()} Created:
            
 **${alert.title || "No title provided."}**:
      
@@ -800,6 +778,7 @@ ${alert.remediationNotes || "No remediation notes provided."}
           select: {
             projectId: true,
             alertNumber: true,
+            alertNumberWithPrefix: true,
           },
           props: {
             isRoot: true,
@@ -808,8 +787,10 @@ ${alert.remediationNotes || "No remediation notes provided."}
 
         const projectId: ObjectID = alert!.projectId!;
         const alertNumber: number = alert!.alertNumber!;
+        const alertNumberWithPrefix: string | undefined =
+          alert!.alertNumberWithPrefix || undefined;
 
-        let feedInfoInMarkdown: string = `**[Alert ${alertNumber}](${(await this.getAlertLinkInDashboard(projectId!, alertId!)).toString()}) was updated.**`;
+        let feedInfoInMarkdown: string = `**[Alert ${alertNumberWithPrefix || "#" + alertNumber}](${(await this.getAlertLinkInDashboard(projectId!, alertId!)).toString()}) was updated.**`;
 
         const createdByUserId: ObjectID | undefined | null =
           onUpdate.updateBy.props.userId;
@@ -1404,13 +1385,15 @@ ${alertSeverity.name}
   }
 
   @CaptureSpan()
-  public async getAlertNumber(data: {
-    alertId: ObjectID;
-  }): Promise<number | null> {
+  public async getAlertNumber(data: { alertId: ObjectID }): Promise<{
+    number: number | null;
+    numberWithPrefix: string | null;
+  }> {
     const alert: Model | null = await this.findOneById({
       id: data.alertId,
       select: {
         alertNumber: true,
+        alertNumberWithPrefix: true,
       },
       props: {
         isRoot: true,
@@ -1421,7 +1404,10 @@ ${alertSeverity.name}
       throw new BadDataException("Alert not found.");
     }
 
-    return alert.alertNumber ? Number(alert.alertNumber) : null;
+    return {
+      number: alert.alertNumber ? Number(alert.alertNumber) : null,
+      numberWithPrefix: alert.alertNumberWithPrefix || null,
+    };
   }
 
   @CaptureSpan()

package/Server/Services/AlertStateTimelineService.ts

@@ -400,7 +400,10 @@ export class Service extends DatabaseService<AlertStateTimeline> {
       stateEmoji = "🔴";
     }
 
-    const alertNumber: number | null = await AlertService.getAlertNumber({
+    const alertNumberResult: {
+      number: number | null;
+      numberWithPrefix: string | null;
+    } = await AlertService.getAlertNumber({
       alertId: createdItem.alertId,
     });
 
@@ -414,7 +417,7 @@ export class Service extends DatabaseService<AlertStateTimeline> {
       displayColor: alertState?.color,
       feedInfoInMarkdown:
         stateEmoji +
-        ` Changed **[Alert ${alertNumber}](${(await AlertService.getAlertLinkInDashboard(projectId!, alertId!)).toString()}) State** to **` +
+        ` Changed **[Alert ${alertNumberResult.numberWithPrefix || "#" + alertNumberResult.number}](${(await AlertService.getAlertLinkInDashboard(projectId!, alertId!)).toString()}) State** to **` +
         stateName +
         "**",
       moreInformationInMarkdown: `**Cause:** 
@@ -464,7 +467,7 @@ ${createdItem.rootCause}`,
         },
         sendMessageBeforeArchiving: {
           _type: "WorkspacePayloadMarkdown",
-          text: `**[Alert ${alertNumber}](${(
+          text: `**[Alert ${alertNumberResult.numberWithPrefix || "#" + alertNumberResult.number}](${(
             await AlertService.getAlertLinkInDashboard(
               createdItem.projectId!,
               createdItem.alertId!,

package/Server/Services/DatabaseService.ts

@@ -1679,6 +1679,18 @@ class DatabaseService<TBaseModel extends BaseModel> extends BaseService {
     });
   }
 
+  @CaptureSpan()
+  protected async atomicIncrementColumnValueByOne(data: {
+    id: ObjectID;
+    columnName: keyof TBaseModel;
+  }): Promise<void> {
+    await this.getRepository().increment(
+      { _id: data.id.toString() } as any,
+      data.columnName as string,
+      1,
+    );
+  }
+
   @CaptureSpan()
   public async searchBy({
     skip,

package/Server/Services/IncidentEpisodeMemberService.ts

@@ -122,6 +122,7 @@ export class Service extends DatabaseService<Model> {
       id: createdItem.incidentId,
       select: {
         incidentNumber: true,
+        incidentNumberWithPrefix: true,
         title: true,
       },
       props: {
@@ -135,6 +136,7 @@ export class Service extends DatabaseService<Model> {
         id: createdItem.incidentEpisodeId,
         select: {
           episodeNumber: true,
+          episodeNumberWithPrefix: true,
           title: true,
         },
         props: {
@@ -148,7 +150,7 @@ export class Service extends DatabaseService<Model> {
       projectId: createdItem.projectId,
       incidentEpisodeFeedEventType: IncidentEpisodeFeedEventType.IncidentAdded,
       displayColor: Yellow500,
-      feedInfoInMarkdown: `**Incident #${incident?.incidentNumber || "N/A"}** added to episode: ${incident?.title || "No title"}`,
+      feedInfoInMarkdown: `**Incident ${incident?.incidentNumberWithPrefix || "#" + (incident?.incidentNumber || "N/A")}** added to episode: ${incident?.title || "No title"}`,
       userId: createdItem.addedByUserId || undefined,
     });
 
@@ -158,7 +160,7 @@ export class Service extends DatabaseService<Model> {
       projectId: createdItem.projectId,
       incidentFeedEventType: IncidentFeedEventType.IncidentUpdated,
       displayColor: Yellow500,
-      feedInfoInMarkdown: `Added to **Episode #${episode?.episodeNumber || "N/A"}**: ${episode?.title || "No title"}`,
+      feedInfoInMarkdown: `Added to **Episode ${episode?.episodeNumberWithPrefix || "#" + (episode?.episodeNumber || "N/A")}**: ${episode?.title || "No title"}`,
       userId: createdItem.addedByUserId || undefined,
     });
 
@@ -216,6 +218,7 @@ export class Service extends DatabaseService<Model> {
             id: member.incidentId,
             select: {
               incidentNumber: true,
+              incidentNumberWithPrefix: true,
               title: true,
             },
             props: {
@@ -231,6 +234,7 @@ export class Service extends DatabaseService<Model> {
                 id: member.incidentEpisodeId,
                 select: {
                   episodeNumber: true,
+                  episodeNumberWithPrefix: true,
                   title: true,
                 },
                 props: {
@@ -245,7 +249,7 @@ export class Service extends DatabaseService<Model> {
               incidentEpisodeFeedEventType:
                 IncidentEpisodeFeedEventType.IncidentRemoved,
               displayColor: Green500,
-              feedInfoInMarkdown: `**Incident #${incident?.incidentNumber || "N/A"}** removed from episode: ${incident?.title || "No title"}`,
+              feedInfoInMarkdown: `**Incident ${incident?.incidentNumberWithPrefix || "#" + (incident?.incidentNumber || "N/A")}** removed from episode: ${incident?.title || "No title"}`,
             });
 
             // Create feed item on incident
@@ -254,7 +258,7 @@ export class Service extends DatabaseService<Model> {
               projectId: member.projectId,
               incidentFeedEventType: IncidentFeedEventType.IncidentUpdated,
               displayColor: Green500,
-              feedInfoInMarkdown: `Removed from **Episode #${episode?.episodeNumber || "N/A"}**: ${episode?.title || "No title"}`,
+              feedInfoInMarkdown: `Removed from **Episode ${episode?.episodeNumberWithPrefix || "#" + (episode?.episodeNumber || "N/A")}**: ${episode?.title || "No title"}`,
             });
           }
         }

package/Server/Services/IncidentEpisodePublicNoteService.ts

@@ -0,0 +1,257 @@
+import CreateBy from "../Types/Database/CreateBy";
+import { OnCreate, OnUpdate } from "../Types/Database/Hooks";
+import DatabaseService from "./DatabaseService";
+import OneUptimeDate from "../../Types/Date";
+import Model from "../../Models/DatabaseModels/IncidentEpisodePublicNote";
+import IncidentEpisodeFeedService from "./IncidentEpisodeFeedService";
+import { IncidentEpisodeFeedEventType } from "../../Models/DatabaseModels/IncidentEpisodeFeed";
+import { Blue500, Indigo500 } from "../../Types/BrandColors";
+import ObjectID from "../../Types/ObjectID";
+import { LIMIT_PER_PROJECT } from "../../Types/Database/LimitMax";
+import IncidentEpisodeService from "./IncidentEpisodeService";
+import IncidentEpisode from "../../Models/DatabaseModels/IncidentEpisode";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import StatusPageSubscriberNotificationStatus from "../../Types/StatusPage/StatusPageSubscriberNotificationStatus";
+import File from "../../Models/DatabaseModels/File";
+import FileAttachmentMarkdownUtil from "../Utils/FileAttachmentMarkdownUtil";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+  }
+
+  @CaptureSpan()
+  public async addNote(data: {
+    userId: ObjectID;
+    incidentEpisodeId: ObjectID;
+    projectId: ObjectID;
+    note: string;
+    attachmentFileIds?: Array<ObjectID>;
+    postedFromSlackMessageId?: string;
+  }): Promise<Model> {
+    const publicNote: Model = new Model();
+    publicNote.createdByUserId = data.userId;
+    publicNote.incidentEpisodeId = data.incidentEpisodeId;
+    publicNote.projectId = data.projectId;
+    publicNote.note = data.note;
+    publicNote.postedAt = OneUptimeDate.getCurrentDate();
+
+    if (data.postedFromSlackMessageId) {
+      publicNote.postedFromSlackMessageId = data.postedFromSlackMessageId;
+    }
+
+    if (data.attachmentFileIds && data.attachmentFileIds.length > 0) {
+      publicNote.attachments = data.attachmentFileIds.map(
+        (fileId: ObjectID) => {
+          const file: File = new File();
+          file.id = fileId;
+          return file;
+        },
+      );
+    }
+
+    return this.create({
+      data: publicNote,
+      props: {
+        isRoot: true,
+      },
+    });
+  }
+
+  @CaptureSpan()
+  public async hasNoteFromSlackMessage(data: {
+    incidentEpisodeId: ObjectID;
+    postedFromSlackMessageId: string;
+  }): Promise<boolean> {
+    const existingNote: Model | null = await this.findOneBy({
+      query: {
+        incidentEpisodeId: data.incidentEpisodeId,
+        postedFromSlackMessageId: data.postedFromSlackMessageId,
+      },
+      select: {
+        _id: true,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    return existingNote !== null;
+  }
+
+  @CaptureSpan()
+  protected override async onBeforeCreate(
+    createBy: CreateBy<Model>,
+  ): Promise<OnCreate<Model>> {
+    if (!createBy.data.postedAt) {
+      createBy.data.postedAt = OneUptimeDate.getCurrentDate();
+    }
+
+    // Set notification status based on shouldStatusPageSubscribersBeNotifiedOnNoteCreated
+    if (
+      createBy.data.shouldStatusPageSubscribersBeNotifiedOnNoteCreated === false
+    ) {
+      createBy.data.subscriberNotificationStatusOnNoteCreated =
+        StatusPageSubscriberNotificationStatus.Skipped;
+      createBy.data.subscriberNotificationStatusMessage =
+        "Notifications skipped as subscribers are not to be notified for this episode note.";
+    } else if (
+      createBy.data.shouldStatusPageSubscribersBeNotifiedOnNoteCreated === true
+    ) {
+      createBy.data.subscriberNotificationStatusOnNoteCreated =
+        StatusPageSubscriberNotificationStatus.Pending;
+    }
+
+    return {
+      createBy: createBy,
+      carryForward: null,
+    };
+  }
+
+  @CaptureSpan()
+  public override async onCreateSuccess(
+    _onCreate: OnCreate<Model>,
+    createdItem: Model,
+  ): Promise<Model> {
+    const userId: ObjectID | null | undefined =
+      createdItem.createdByUserId || createdItem.createdByUser?.id;
+
+    const incidentEpisodeId: ObjectID = createdItem.incidentEpisodeId!;
+    const projectId: ObjectID = createdItem.projectId!;
+    const episodeNumberResult: {
+      number: number | null;
+      numberWithPrefix: string | null;
+    } = await IncidentEpisodeService.getEpisodeNumber({
+      episodeId: incidentEpisodeId,
+    });
+
+    const attachmentsMarkdown: string = await this.getAttachmentsMarkdown(
+      createdItem.id!,
+      "/incident-episode-public-note/attachment",
+    );
+
+    await IncidentEpisodeFeedService.createIncidentEpisodeFeedItem({
+      incidentEpisodeId: createdItem.incidentEpisodeId!,
+      projectId: createdItem.projectId!,
+      incidentEpisodeFeedEventType: IncidentEpisodeFeedEventType.PublicNote,
+      displayColor: Indigo500,
+      userId: userId || undefined,
+      feedInfoInMarkdown: `📄 posted **public note** for this [Episode ${episodeNumberResult.numberWithPrefix || "#" + episodeNumberResult.number}](${(await IncidentEpisodeService.getEpisodeLinkInDashboard(projectId!, incidentEpisodeId!)).toString()}) on status page:
+
+${(createdItem.note || "") + attachmentsMarkdown}
+          `,
+    });
+
+    return createdItem;
+  }
+
+  @CaptureSpan()
+  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: {
+          incidentEpisodeId: true,
+          projectId: true,
+          incidentEpisode: {
+            _id: true,
+            episodeNumber: true,
+            episodeNumberWithPrefix: true,
+            projectId: true,
+          },
+          note: true,
+          createdByUserId: true,
+          createdByUser: {
+            _id: true,
+          },
+        },
+      });
+
+      const userId: ObjectID | null | undefined =
+        onUpdate.updateBy.props.userId;
+
+      for (const updatedItem of updatedItems) {
+        const episode: IncidentEpisode = updatedItem.incidentEpisode!;
+
+        const attachmentsMarkdown: string = await this.getAttachmentsMarkdown(
+          updatedItem.id!,
+          "/incident-episode-public-note/attachment",
+        );
+
+        await IncidentEpisodeFeedService.createIncidentEpisodeFeedItem({
+          incidentEpisodeId: updatedItem.incidentEpisodeId!,
+          projectId: updatedItem.projectId!,
+          incidentEpisodeFeedEventType: IncidentEpisodeFeedEventType.PublicNote,
+          displayColor: Blue500,
+          userId: userId || undefined,
+          feedInfoInMarkdown: `📄 updated **Public Note** for this [Episode ${episode.episodeNumberWithPrefix || "#" + episode.episodeNumber}](${(await IncidentEpisodeService.getEpisodeLinkInDashboard(episode.projectId!, episode.id!)).toString()})
+
+${(updatedItem.note || "") + attachmentsMarkdown}
+                  `,
+        });
+      }
+    }
+    return onUpdate;
+  }
+
+  private async getAttachmentsMarkdown(
+    modelId: ObjectID,
+    attachmentApiPath: string,
+  ): Promise<string> {
+    if (!modelId) {
+      return "";
+    }
+
+    const noteWithAttachments: Model | null = await this.findOneById({
+      id: modelId,
+      select: {
+        attachments: {
+          _id: true,
+        },
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    if (!noteWithAttachments || !noteWithAttachments.attachments) {
+      return "";
+    }
+
+    const attachmentIds: Array<ObjectID> = noteWithAttachments.attachments
+      .map((file: File) => {
+        if (file.id) {
+          return file.id;
+        }
+
+        if (file._id) {
+          return new ObjectID(file._id);
+        }
+
+        return null;
+      })
+      .filter((id: ObjectID | null): id is ObjectID => {
+        return Boolean(id);
+      });
+
+    if (!attachmentIds.length) {
+      return "";
+    }
+
+    return await FileAttachmentMarkdownUtil.buildAttachmentMarkdown({
+      modelId,
+      attachmentIds,
+      attachmentApiPath,
+    });
+  }
+}
+
+export default new Service();