@oneuptime/common 8.0.5579 → 8.0.5581

package/Server/API/StatusPageAnnouncementAPI.ts

@@ -0,0 +1,98 @@
+import StatusPageAnnouncement from "../../Models/DatabaseModels/StatusPageAnnouncement";
+import File from "../../Models/DatabaseModels/File";
+import NotFoundException from "../../Types/Exception/NotFoundException";
+import ObjectID from "../../Types/ObjectID";
+import StatusPageAnnouncementService, {
+  Service as StatusPageAnnouncementServiceType,
+} from "../Services/StatusPageAnnouncementService";
+import Response from "../Utils/Response";
+import BaseAPI from "./BaseAPI";
+import UserMiddleware from "../Middleware/UserAuthorization";
+import CommonAPI from "./CommonAPI";
+import DatabaseCommonInteractionProps from "../../Types/BaseDatabase/DatabaseCommonInteractionProps";
+import {
+  ExpressRequest,
+  ExpressResponse,
+  NextFunction,
+} from "../Utils/Express";
+
+export default class StatusPageAnnouncementAPI extends BaseAPI<
+  StatusPageAnnouncement,
+  StatusPageAnnouncementServiceType
+> {
+  public constructor() {
+    super(StatusPageAnnouncement, StatusPageAnnouncementService);
+
+    this.router.get(
+      `${new this.entityType().getCrudApiPath()?.toString()}/attachment/:projectId/:announcementId/:fileId`,
+      UserMiddleware.getUserMiddleware,
+      async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
+        try {
+          await this.getAttachment(req, res);
+        } catch (err) {
+          next(err);
+        }
+      },
+    );
+  }
+
+  private async getAttachment(
+    req: ExpressRequest,
+    res: ExpressResponse,
+  ): Promise<void> {
+    const announcementIdParam: string | undefined =
+      req.params["announcementId"];
+    const fileIdParam: string | undefined = req.params["fileId"];
+
+    if (!announcementIdParam || !fileIdParam) {
+      throw new NotFoundException("Attachment not found");
+    }
+
+    let announcementId: ObjectID;
+    let fileId: ObjectID;
+
+    try {
+      announcementId = new ObjectID(announcementIdParam);
+      fileId = new ObjectID(fileIdParam);
+    } catch {
+      throw new NotFoundException("Attachment not found");
+    }
+
+    const props: DatabaseCommonInteractionProps =
+      await CommonAPI.getDatabaseCommonInteractionProps(req);
+
+    const announcement: StatusPageAnnouncement | null =
+      await this.service.findOneBy({
+        query: {
+          _id: announcementId,
+        },
+        select: {
+          attachments: {
+            _id: true,
+            file: true,
+            fileType: true,
+            name: true,
+          },
+        },
+        props,
+      });
+
+    const attachment: File | undefined = announcement?.attachments?.find(
+      (file: File) => {
+        const attachmentId: string | null = file._id
+          ? file._id.toString()
+          : file.id
+            ? file.id.toString()
+            : null;
+        return attachmentId === fileId.toString();
+      },
+    );
+
+    if (!attachment || !attachment.file) {
+      throw new NotFoundException("Attachment not found");
+    }
+
+    Response.setNoCacheHeaders(res);
+    return Response.sendFileResponse(req, res, attachment);
+  }
+}

package/Server/API/UserAPI.ts

@@ -0,0 +1,95 @@
+import User from "../../Models/DatabaseModels/User";
+import NotFoundException from "../../Types/Exception/NotFoundException";
+import ObjectID from "../../Types/ObjectID";
+import UserService, {
+  Service as UserServiceType,
+} from "../Services/UserService";
+import { ExpressRequest, ExpressResponse } from "../Utils/Express";
+import logger from "../Utils/Logger";
+import Response from "../Utils/Response";
+import BaseAPI from "./BaseAPI";
+
+const BLANK_PROFILE_PICTURE_PATH: string =
+  "/usr/src/Common/UI/Images/users/blank-profile.svg";
+
+export default class UserAPI extends BaseAPI<User, UserServiceType> {
+  public constructor() {
+    super(User, UserService);
+
+    this.router.get(
+      `${new this.entityType().getCrudApiPath()?.toString()}/profile-picture/:userId`,
+      async (req: ExpressRequest, res: ExpressResponse) => {
+        const userIdParam: string | undefined = req.params["userId"];
+
+        if (!userIdParam) {
+          return this.sendBlankProfile(req, res);
+        }
+
+        let userId: ObjectID;
+
+        try {
+          userId = new ObjectID(userIdParam);
+        } catch {
+          return this.sendBlankProfile(req, res);
+        }
+
+        try {
+          const profilePictureSelect: {
+            profilePictureFile: {
+              _id: boolean;
+              file: boolean;
+              fileType: boolean;
+              name: boolean;
+            };
+          } = {
+            profilePictureFile: {
+              _id: true,
+              file: true,
+              fileType: true,
+              name: true,
+            },
+          };
+
+          const userById: User | null = await UserService.findOneBy({
+            query: {
+              _id: userId,
+            },
+            select: profilePictureSelect,
+            props: {
+              isRoot: true,
+            },
+          });
+
+          if (userById && userById.profilePictureFile) {
+            Response.setNoCacheHeaders(res);
+            return Response.sendFileResponse(
+              req,
+              res,
+              userById.profilePictureFile,
+            );
+          }
+
+          return this.sendBlankProfile(req, res);
+        } catch (error) {
+          logger.error(error);
+          return this.sendBlankProfile(req, res);
+        }
+      },
+    );
+  }
+
+  private sendBlankProfile(req: ExpressRequest, res: ExpressResponse): void {
+    Response.setNoCacheHeaders(res);
+
+    try {
+      Response.sendFileByPath(req, res, BLANK_PROFILE_PICTURE_PATH);
+    } catch (error) {
+      logger.error(error);
+      Response.sendErrorResponse(
+        req,
+        res,
+        new NotFoundException("User profile picture not found"),
+      );
+    }
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/1763471659817-MigrationName.ts

@@ -0,0 +1,79 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class MigrationName1763471659817 implements MigrationInterface {
+  public name = "MigrationName1763471659817";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `CREATE TABLE "IncidentInternalNoteFile" ("incidentInternalNoteId" uuid NOT NULL, "fileId" uuid NOT NULL, CONSTRAINT "PK_1e97a749db84f9dc65ee162dd6b" PRIMARY KEY ("incidentInternalNoteId", "fileId"))`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_0edb0291ff3e97197269d77dc4" ON "IncidentInternalNoteFile" ("incidentInternalNoteId") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_b30b49d21a553c06bd0ff3acf5" ON "IncidentInternalNoteFile" ("fileId") `,
+    );
+    await queryRunner.query(
+      `CREATE TABLE "IncidentPublicNoteFile" ("incidentPublicNoteId" uuid NOT NULL, "fileId" uuid NOT NULL, CONSTRAINT "PK_42d2fe75b663f8fa20421f31e78" PRIMARY KEY ("incidentPublicNoteId", "fileId"))`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_e5c4a5671b2bb51a9918f1f203" ON "IncidentPublicNoteFile" ("incidentPublicNoteId") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_81a5bc92f59cb5577746ee51ba" ON "IncidentPublicNoteFile" ("fileId") `,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicyScheduleLayer" ALTER COLUMN "rotation" SET DEFAULT '{"_type":"Recurring","value":{"intervalType":"Day","intervalCount":{"_type":"PositiveNumber","value":1}}}'`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicyScheduleLayer" ALTER COLUMN "restrictionTimes" SET DEFAULT '{"_type":"RestrictionTimes","value":{"restictionType":"None","dayRestrictionTimes":null,"weeklyRestrictionTimes":[]}}'`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentInternalNoteFile" ADD CONSTRAINT "FK_0edb0291ff3e97197269d77dc48" FOREIGN KEY ("incidentInternalNoteId") REFERENCES "IncidentInternalNote"("_id") ON DELETE CASCADE ON UPDATE CASCADE`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentInternalNoteFile" ADD CONSTRAINT "FK_b30b49d21a553c06bd0ff3acf5f" FOREIGN KEY ("fileId") REFERENCES "File"("_id") ON DELETE CASCADE ON UPDATE CASCADE`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentPublicNoteFile" ADD CONSTRAINT "FK_e5c4a5671b2bb51a9918f1f203d" FOREIGN KEY ("incidentPublicNoteId") REFERENCES "IncidentPublicNote"("_id") ON DELETE CASCADE ON UPDATE CASCADE`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentPublicNoteFile" ADD CONSTRAINT "FK_81a5bc92f59cb5577746ee51baf" FOREIGN KEY ("fileId") REFERENCES "File"("_id") ON DELETE CASCADE ON UPDATE CASCADE`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "IncidentPublicNoteFile" DROP CONSTRAINT "FK_81a5bc92f59cb5577746ee51baf"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentPublicNoteFile" DROP CONSTRAINT "FK_e5c4a5671b2bb51a9918f1f203d"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentInternalNoteFile" DROP CONSTRAINT "FK_b30b49d21a553c06bd0ff3acf5f"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentInternalNoteFile" DROP CONSTRAINT "FK_0edb0291ff3e97197269d77dc48"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicyScheduleLayer" ALTER COLUMN "restrictionTimes" SET DEFAULT '{"_type": "RestrictionTimes", "value": {"restictionType": "None", "dayRestrictionTimes": null, "weeklyRestrictionTimes": []}}'`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicyScheduleLayer" ALTER COLUMN "rotation" SET DEFAULT '{"_type": "Recurring", "value": {"intervalType": "Day", "intervalCount": {"_type": "PositiveNumber", "value": 1}}}'`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_81a5bc92f59cb5577746ee51ba"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_e5c4a5671b2bb51a9918f1f203"`,
+    );
+    await queryRunner.query(`DROP TABLE "IncidentPublicNoteFile"`);
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_b30b49d21a553c06bd0ff3acf5"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_0edb0291ff3e97197269d77dc4"`,
+    );
+    await queryRunner.query(`DROP TABLE "IncidentInternalNoteFile"`);
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/1763477560906-MigrationName.ts

@@ -0,0 +1,81 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class MigrationName1763477560906 implements MigrationInterface {
+  public name = "MigrationName1763477560906";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `CREATE TABLE "ScheduledMaintenanceInternalNoteFile" ("scheduledMaintenanceInternalNoteId" uuid NOT NULL, "fileId" uuid NOT NULL, CONSTRAINT "PK_fddb744dc7cf400724befe5ba91" PRIMARY KEY ("scheduledMaintenanceInternalNoteId", "fileId"))`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_ac92a60535a6d598c9619fd199" ON "ScheduledMaintenanceInternalNoteFile" ("scheduledMaintenanceInternalNoteId") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_daee340befeece208b507a4242" ON "ScheduledMaintenanceInternalNoteFile" ("fileId") `,
+    );
+    await queryRunner.query(
+      `CREATE TABLE "ScheduledMaintenancePublicNoteFile" ("scheduledMaintenancePublicNoteId" uuid NOT NULL, "fileId" uuid NOT NULL, CONSTRAINT "PK_373f78b83aa76e5250df8ebaed7" PRIMARY KEY ("scheduledMaintenancePublicNoteId", "fileId"))`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_af6905f89ca8108ed0f478fd37" ON "ScheduledMaintenancePublicNoteFile" ("scheduledMaintenancePublicNoteId") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_f09af6332e0b89f134472f0442" ON "ScheduledMaintenancePublicNoteFile" ("fileId") `,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicyScheduleLayer" ALTER COLUMN "rotation" SET DEFAULT '{"_type":"Recurring","value":{"intervalType":"Day","intervalCount":{"_type":"PositiveNumber","value":1}}}'`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicyScheduleLayer" ALTER COLUMN "restrictionTimes" SET DEFAULT '{"_type":"RestrictionTimes","value":{"restictionType":"None","dayRestrictionTimes":null,"weeklyRestrictionTimes":[]}}'`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ScheduledMaintenanceInternalNoteFile" ADD CONSTRAINT "FK_ac92a60535a6d598c9619fd1999" FOREIGN KEY ("scheduledMaintenanceInternalNoteId") REFERENCES "ScheduledMaintenanceInternalNote"("_id") ON DELETE CASCADE ON UPDATE CASCADE`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ScheduledMaintenanceInternalNoteFile" ADD CONSTRAINT "FK_daee340befeece208b507a42423" FOREIGN KEY ("fileId") REFERENCES "File"("_id") ON DELETE CASCADE ON UPDATE CASCADE`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ScheduledMaintenancePublicNoteFile" ADD CONSTRAINT "FK_af6905f89ca8108ed0f478fd376" FOREIGN KEY ("scheduledMaintenancePublicNoteId") REFERENCES "ScheduledMaintenancePublicNote"("_id") ON DELETE CASCADE ON UPDATE CASCADE`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ScheduledMaintenancePublicNoteFile" ADD CONSTRAINT "FK_f09af6332e0b89f134472f0442a" FOREIGN KEY ("fileId") REFERENCES "File"("_id") ON DELETE CASCADE ON UPDATE CASCADE`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "ScheduledMaintenancePublicNoteFile" DROP CONSTRAINT "FK_f09af6332e0b89f134472f0442a"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ScheduledMaintenancePublicNoteFile" DROP CONSTRAINT "FK_af6905f89ca8108ed0f478fd376"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ScheduledMaintenanceInternalNoteFile" DROP CONSTRAINT "FK_daee340befeece208b507a42423"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ScheduledMaintenanceInternalNoteFile" DROP CONSTRAINT "FK_ac92a60535a6d598c9619fd1999"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicyScheduleLayer" ALTER COLUMN "restrictionTimes" SET DEFAULT '{"_type": "RestrictionTimes", "value": {"restictionType": "None", "dayRestrictionTimes": null, "weeklyRestrictionTimes": []}}'`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicyScheduleLayer" ALTER COLUMN "rotation" SET DEFAULT '{"_type": "Recurring", "value": {"intervalType": "Day", "intervalCount": {"_type": "PositiveNumber", "value": 1}}}'`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_f09af6332e0b89f134472f0442"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_af6905f89ca8108ed0f478fd37"`,
+    );
+    await queryRunner.query(`DROP TABLE "ScheduledMaintenancePublicNoteFile"`);
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_daee340befeece208b507a4242"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_ac92a60535a6d598c9619fd199"`,
+    );
+    await queryRunner.query(
+      `DROP TABLE "ScheduledMaintenanceInternalNoteFile"`,
+    );
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/1763480947474-MigrationName.ts

@@ -0,0 +1,79 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class MigrationName1763480947474 implements MigrationInterface {
+  public name = "MigrationName1763480947474";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `CREATE TABLE "StatusPageAnnouncementFile" ("statusPageAnnouncementId" uuid NOT NULL, "fileId" uuid NOT NULL, CONSTRAINT "PK_1323a0215e608ece58a96816134" PRIMARY KEY ("statusPageAnnouncementId", "fileId"))`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_b152a77a26a67d2e76160ba15e" ON "StatusPageAnnouncementFile" ("statusPageAnnouncementId") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_2f78e2d073bf58013c962ce482" ON "StatusPageAnnouncementFile" ("fileId") `,
+    );
+    await queryRunner.query(
+      `CREATE TABLE "AlertInternalNoteFile" ("alertInternalNoteId" uuid NOT NULL, "fileId" uuid NOT NULL, CONSTRAINT "PK_a5370c68590b3db5c3635d364aa" PRIMARY KEY ("alertInternalNoteId", "fileId"))`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_09507cdab877a482edcc4c0593" ON "AlertInternalNoteFile" ("alertInternalNoteId") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_77dc8a31bd4ebb0882450abdde" ON "AlertInternalNoteFile" ("fileId") `,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicyScheduleLayer" ALTER COLUMN "rotation" SET DEFAULT '{"_type":"Recurring","value":{"intervalType":"Day","intervalCount":{"_type":"PositiveNumber","value":1}}}'`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicyScheduleLayer" ALTER COLUMN "restrictionTimes" SET DEFAULT '{"_type":"RestrictionTimes","value":{"restictionType":"None","dayRestrictionTimes":null,"weeklyRestrictionTimes":[]}}'`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "StatusPageAnnouncementFile" ADD CONSTRAINT "FK_b152a77a26a67d2e76160ba15e3" FOREIGN KEY ("statusPageAnnouncementId") REFERENCES "StatusPageAnnouncement"("_id") ON DELETE CASCADE ON UPDATE CASCADE`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "StatusPageAnnouncementFile" ADD CONSTRAINT "FK_2f78e2d073bf58013c962ce4827" FOREIGN KEY ("fileId") REFERENCES "File"("_id") ON DELETE CASCADE ON UPDATE CASCADE`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "AlertInternalNoteFile" ADD CONSTRAINT "FK_09507cdab877a482edcc4c05933" FOREIGN KEY ("alertInternalNoteId") REFERENCES "AlertInternalNote"("_id") ON DELETE CASCADE ON UPDATE CASCADE`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "AlertInternalNoteFile" ADD CONSTRAINT "FK_77dc8a31bd4ebb0882450abdde9" FOREIGN KEY ("fileId") REFERENCES "File"("_id") ON DELETE CASCADE ON UPDATE CASCADE`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "AlertInternalNoteFile" DROP CONSTRAINT "FK_77dc8a31bd4ebb0882450abdde9"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "AlertInternalNoteFile" DROP CONSTRAINT "FK_09507cdab877a482edcc4c05933"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "StatusPageAnnouncementFile" DROP CONSTRAINT "FK_2f78e2d073bf58013c962ce4827"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "StatusPageAnnouncementFile" DROP CONSTRAINT "FK_b152a77a26a67d2e76160ba15e3"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicyScheduleLayer" ALTER COLUMN "restrictionTimes" SET DEFAULT '{"_type": "RestrictionTimes", "value": {"restictionType": "None", "dayRestrictionTimes": null, "weeklyRestrictionTimes": []}}'`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicyScheduleLayer" ALTER COLUMN "rotation" SET DEFAULT '{"_type": "Recurring", "value": {"intervalType": "Day", "intervalCount": {"_type": "PositiveNumber", "value": 1}}}'`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_77dc8a31bd4ebb0882450abdde"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_09507cdab877a482edcc4c0593"`,
+    );
+    await queryRunner.query(`DROP TABLE "AlertInternalNoteFile"`);
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_2f78e2d073bf58013c962ce482"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_b152a77a26a67d2e76160ba15e"`,
+    );
+    await queryRunner.query(`DROP TABLE "StatusPageAnnouncementFile"`);
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/Index.ts

@@ -182,6 +182,9 @@ import { MigrationName1761834523183 } from "./1761834523183-MigrationName";
 import { MigrationName1762181014879 } from "./1762181014879-MigrationName";
 import { MigrationName1762554602716 } from "./1762554602716-MigrationName";
 import { MigrationName1762890441920 } from "./1762890441920-MigrationName";
+import { MigrationName1763471659817 } from "./1763471659817-MigrationName";
+import { MigrationName1763477560906 } from "./1763477560906-MigrationName";
+import { MigrationName1763480947474 } from "./1763480947474-MigrationName";
 
 export default [
   InitialMigration,
@@ -368,4 +371,7 @@ export default [
   MigrationName1762181014879,
   MigrationName1762554602716,
   MigrationName1762890441920,
+  MigrationName1763471659817,
+  MigrationName1763477560906,
+  MigrationName1763480947474,
 ];

package/Server/Middleware/ProjectAuthorization.ts

@@ -24,7 +24,9 @@ export default class ProjectMiddleware {
   @CaptureSpan()
   public static getProjectId(req: ExpressRequest): ObjectID | null {
     let projectId: ObjectID | null = null;
-    if (req.params && req.params["tenantid"]) {
+    if (req.params && req.params["projectId"]) {
+      projectId = new ObjectID(req.params["projectId"]);
+    } else if (req.params && req.params["tenantid"]) {
       projectId = new ObjectID(req.params["tenantid"]);
     } else if (req.query && req.query["tenantid"]) {
       projectId = new ObjectID(req.query["tenantid"] as string);

package/Server/Services/AlertInternalNoteService.ts

@@ -9,6 +9,8 @@ import { LIMIT_PER_PROJECT } from "../../Types/Database/LimitMax";
 import Alert from "../../Models/DatabaseModels/Alert";
 import AlertService from "./AlertService";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import File from "../../Models/DatabaseModels/File";
+import FileAttachmentMarkdownUtil from "../Utils/FileAttachmentMarkdownUtil";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
@@ -21,6 +23,7 @@ export class Service extends DatabaseService<Model> {
     alertId: ObjectID;
     projectId: ObjectID;
     note: string;
+    attachmentFileIds?: Array<ObjectID>;
   }): Promise<Model> {
     const internalNote: Model = new Model();
     internalNote.createdByUserId = data.userId;
@@ -28,6 +31,16 @@ export class Service extends DatabaseService<Model> {
     internalNote.projectId = data.projectId;
     internalNote.note = data.note;
 
+    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: {
@@ -50,6 +63,11 @@ export class Service extends DatabaseService<Model> {
       alertId: alertId,
     });
 
+    const attachmentsMarkdown: string = await this.getAttachmentsMarkdown(
+      createdItem.id!,
+      "/alert-internal-note/attachment",
+    );
+
     await AlertFeedService.createAlertFeedItem({
       alertId: createdItem.alertId!,
       projectId: createdItem.projectId!,
@@ -59,7 +77,7 @@ export class Service extends DatabaseService<Model> {
 
       feedInfoInMarkdown: `📄 posted **private note** for this [Alert ${alertNumber}](${(await AlertService.getAlertLinkInDashboard(createdItem.projectId!, alertId)).toString()}):
       
-${createdItem.note}
+${(createdItem.note || "") + attachmentsMarkdown}
                 `,
       workspaceNotification: {
         sendWorkspaceNotification: true,
@@ -104,6 +122,10 @@ ${createdItem.note}
 
       for (const updatedItem of updatedItems) {
         const alert: Alert = updatedItem.alert!;
+        const attachmentsMarkdown: string = await this.getAttachmentsMarkdown(
+          updatedItem.id!,
+          "/alert-internal-note/attachment",
+        );
         await AlertFeedService.createAlertFeedItem({
           alertId: updatedItem.alertId!,
           projectId: updatedItem.projectId!,
@@ -113,7 +135,7 @@ ${createdItem.note}
 
           feedInfoInMarkdown: `📄 updated **Private Note** for this [Alert ${alert.alertNumber}](${(await AlertService.getAlertLinkInDashboard(alert.projectId!, alert.id!)).toString()})
           
-${updatedItem.note}
+${(updatedItem.note || "") + attachmentsMarkdown}
                     `,
           workspaceNotification: {
             sendWorkspaceNotification: true,
@@ -124,6 +146,57 @@ ${updatedItem.note}
     }
     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();