@oneuptime/common 8.0.5579 → 8.0.5581

package/Server/API/StatusPageAPI.ts

@@ -63,6 +63,7 @@ import ScheduledMaintenanceState from "../../Models/DatabaseModels/ScheduledMain
 import ScheduledMaintenanceStateTimeline from "../../Models/DatabaseModels/ScheduledMaintenanceStateTimeline";
 import StatusPage from "../../Models/DatabaseModels/StatusPage";
 import StatusPageAnnouncement from "../../Models/DatabaseModels/StatusPageAnnouncement";
+import File from "../../Models/DatabaseModels/File";
 import StatusPageDomain from "../../Models/DatabaseModels/StatusPageDomain";
 import StatusPageFooterLink from "../../Models/DatabaseModels/StatusPageFooterLink";
 import StatusPageGroup from "../../Models/DatabaseModels/StatusPageGroup";
@@ -86,11 +87,57 @@ import EmailTemplateType from "../../Types/Email/EmailTemplateType";
 import Hostname from "../../Types/API/Hostname";
 import Protocol from "../../Types/API/Protocol";
 import DatabaseConfig from "../DatabaseConfig";
-import { FileRoute } from "../../ServiceRoute";
+import { StatusPageApiRoute } from "../../ServiceRoute";
 import ProjectSmtpConfigService from "../Services/ProjectSmtpConfigService";
 import ForbiddenException from "../../Types/Exception/ForbiddenException";
 import SlackUtil from "../Utils/Workspace/Slack/Slack";
 
+type ResolveStatusPageIdOrThrowFunction = (
+  statusPageIdOrDomain: string,
+) => Promise<ObjectID>;
+
+const resolveStatusPageIdOrThrow: ResolveStatusPageIdOrThrowFunction = async (
+  statusPageIdOrDomain: string,
+): Promise<ObjectID> => {
+  if (!statusPageIdOrDomain) {
+    throw new NotFoundException("Status Page not found");
+  }
+
+  if (statusPageIdOrDomain.includes(".")) {
+    const statusPageDomain: StatusPageDomain | null =
+      await StatusPageDomainService.findOneBy({
+        query: {
+          fullDomain: statusPageIdOrDomain,
+          domain: {
+            isVerified: true,
+          } as any,
+        },
+        select: {
+          statusPageId: true,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+    if (!statusPageDomain || !statusPageDomain.statusPageId) {
+      throw new NotFoundException("Status Page not found");
+    }
+
+    return statusPageDomain.statusPageId;
+  }
+
+  try {
+    return new ObjectID(statusPageIdOrDomain);
+  } catch (err) {
+    logger.error(
+      `Error converting statusPageIdOrDomain to ObjectID: ${statusPageIdOrDomain}`,
+    );
+    logger.error(err);
+    throw new NotFoundException("Status Page not found");
+  }
+};
+
 export default class StatusPageAPI extends BaseAPI<
   StatusPage,
   StatusPageServiceType
@@ -190,89 +237,198 @@ export default class StatusPageAPI extends BaseAPI<
     this.router.get(
       `${new this.entityType().getCrudApiPath()?.toString()}/favicon/:statusPageIdOrDomain`,
       async (req: ExpressRequest, res: ExpressResponse) => {
-        const statusPageIdOrDomain: string = req.params[
-          "statusPageIdOrDomain"
-        ] as string;
-
-        let statusPageId: ObjectID | null = null;
-
-        if (statusPageIdOrDomain && statusPageIdOrDomain.includes(".")) {
-          // then this is a domain and not the status page id. We need to get the status page id from the domain.
+        try {
+          const statusPageId: ObjectID = await resolveStatusPageIdOrThrow(
+            req.params["statusPageIdOrDomain"] as string,
+          );
 
-          const statusPageDomain: StatusPageDomain | null =
-            await StatusPageDomainService.findOneBy({
+          const statusPage: StatusPage | null =
+            await StatusPageService.findOneBy({
               query: {
-                fullDomain: statusPageIdOrDomain,
-                domain: {
-                  isVerified: true,
-                } as any,
+                _id: statusPageId,
               },
               select: {
-                statusPageId: true,
+                faviconFile: {
+                  file: true,
+                  _id: true,
+                  fileType: true,
+                  name: true,
+                },
               },
               props: {
                 isRoot: true,
               },
             });
 
-          if (!statusPageDomain || !statusPageDomain.statusPageId) {
-            return Response.sendErrorResponse(
+          if (!statusPage || !statusPage.faviconFile) {
+            logger.debug("Favicon file not found. Returning default favicon.");
+
+            return Response.sendFileByPath(
               req,
               res,
-              new NotFoundException("Status Page not found"),
+              `/usr/src/Common/UI/Images/favicon/status-green.png`,
             );
           }
 
-          statusPageId = statusPageDomain.statusPageId;
-        } else {
-          // then this is a status page id. We need to get the status page id from the id.
-          try {
-            statusPageId = new ObjectID(statusPageIdOrDomain);
-          } catch (err) {
-            logger.error(err);
+          logger.debug(
+            `Favicon file found. Sending file: ${statusPage.faviconFile.name}`,
+          );
+
+          return Response.sendFileResponse(req, res, statusPage.faviconFile);
+        } catch (error) {
+          if (error instanceof NotFoundException) {
+            return Response.sendErrorResponse(req, res, error);
+          }
+
+          logger.error(error);
+          return Response.sendErrorResponse(
+            req,
+            res,
+            new NotFoundException("Status Page not found"),
+          );
+        }
+      },
+    );
+
+    this.router.get(
+      `${new this.entityType().getCrudApiPath()?.toString()}/logo/:statusPageIdOrDomain`,
+      async (req: ExpressRequest, res: ExpressResponse) => {
+        try {
+          const statusPageId: ObjectID = await resolveStatusPageIdOrThrow(
+            req.params["statusPageIdOrDomain"] as string,
+          );
+
+          const statusPage: StatusPage | null =
+            await StatusPageService.findOneBy({
+              query: {
+                _id: statusPageId,
+              },
+              select: {
+                logoFile: {
+                  file: true,
+                  _id: true,
+                  fileType: true,
+                  name: true,
+                },
+              },
+              props: {
+                isRoot: true,
+              },
+            });
+
+          if (!statusPage || !statusPage.logoFile) {
             return Response.sendErrorResponse(
               req,
               res,
-              new NotFoundException("Status Page not found"),
+              new NotFoundException("Status Page logo not found"),
             );
           }
+
+          return Response.sendFileResponse(req, res, statusPage.logoFile);
+        } catch (error) {
+          if (error instanceof NotFoundException) {
+            return Response.sendErrorResponse(req, res, error);
+          }
+
+          logger.error(error);
+          return Response.sendErrorResponse(
+            req,
+            res,
+            new NotFoundException("Status Page logo not found"),
+          );
         }
+      },
+    );
 
-        const statusPage: StatusPage | null = await StatusPageService.findOneBy(
-          {
-            query: {
-              _id: statusPageId,
-            },
-            select: {
-              faviconFile: {
-                file: true,
-                _id: true,
-                fileType: true,
-                name: true,
+    this.router.get(
+      `${new this.entityType().getCrudApiPath()?.toString()}/cover-image/:statusPageIdOrDomain`,
+      async (req: ExpressRequest, res: ExpressResponse) => {
+        try {
+          const statusPageId: ObjectID = await resolveStatusPageIdOrThrow(
+            req.params["statusPageIdOrDomain"] as string,
+          );
+
+          const statusPage: StatusPage | null =
+            await StatusPageService.findOneBy({
+              query: {
+                _id: statusPageId,
               },
-            },
-            props: {
-              isRoot: true,
-            },
-          },
-        );
+              select: {
+                coverImageFile: {
+                  file: true,
+                  _id: true,
+                  fileType: true,
+                  name: true,
+                },
+              },
+              props: {
+                isRoot: true,
+              },
+            });
 
-        if (!statusPage || !statusPage.faviconFile) {
-          logger.debug("Favicon file not found. Returning default favicon.");
+          if (!statusPage || !statusPage.coverImageFile) {
+            return Response.sendErrorResponse(
+              req,
+              res,
+              new NotFoundException("Status Page cover image not found"),
+            );
+          }
 
-          // return default favicon.
-          return Response.sendFileByPath(
+          return Response.sendFileResponse(req, res, statusPage.coverImageFile);
+        } catch (error) {
+          if (error instanceof NotFoundException) {
+            return Response.sendErrorResponse(req, res, error);
+          }
+
+          logger.error(error);
+          return Response.sendErrorResponse(
             req,
             res,
-            `/usr/src/Common/UI/Images/favicon/status-green.png`,
+            new NotFoundException("Status Page cover image not found"),
           );
         }
+      },
+    );
 
-        logger.debug(
-          `Favicon file found. Sending file: ${statusPage.faviconFile.name}`,
-        );
+    this.router.get(
+      `${new this.entityType()
+        .getCrudApiPath()
+        ?.toString()}/incident-public-note/attachment/:statusPageId/:incidentId/:noteId/:fileId`,
+      UserMiddleware.getUserMiddleware,
+      async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
+        try {
+          await this.getIncidentPublicNoteAttachment(req, res);
+        } catch (err) {
+          next(err);
+        }
+      },
+    );
 
-        return Response.sendFileResponse(req, res, statusPage.faviconFile!);
+    this.router.get(
+      `${new this.entityType()
+        .getCrudApiPath()
+        ?.toString()}/scheduled-maintenance-public-note/attachment/:statusPageId/:scheduledMaintenanceId/:noteId/:fileId`,
+      UserMiddleware.getUserMiddleware,
+      async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
+        try {
+          await this.getScheduledMaintenancePublicNoteAttachment(req, res);
+        } catch (err) {
+          next(err);
+        }
+      },
+    );
+
+    this.router.get(
+      `${new this.entityType()
+        .getCrudApiPath()
+        ?.toString()}/status-page-announcement/attachment/:statusPageId/:announcementId/:fileId`,
+      UserMiddleware.getUserMiddleware,
+      async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
+        try {
+          await this.getStatusPageAnnouncementAttachment(req, res);
+        } catch (err) {
+          next(err);
+        }
       },
     );
 
@@ -1269,6 +1425,10 @@ export default class StatusPageAPI extends BaseAPI<
                 note: true,
                 incidentId: true,
                 postedAt: true,
+                attachments: {
+                  _id: true,
+                  name: true,
+                },
               },
               sort: {
                 postedAt: SortOrder.Descending, // new note first
@@ -1454,6 +1614,10 @@ export default class StatusPageAPI extends BaseAPI<
                   postedAt: true,
                   note: true,
                   scheduledMaintenanceId: true,
+                  attachments: {
+                    _id: true,
+                    name: true,
+                  },
                 },
                 sort: {
                   postedAt: SortOrder.Ascending,
@@ -1993,6 +2157,10 @@ export default class StatusPageAPI extends BaseAPI<
             postedAt: true,
             note: true,
             scheduledMaintenanceId: true,
+            attachments: {
+              _id: true,
+              name: true,
+            },
           },
           sort: {
             postedAt: SortOrder.Ascending,
@@ -2219,6 +2387,10 @@ export default class StatusPageAPI extends BaseAPI<
             _id: true,
             name: true,
           },
+          attachments: {
+            _id: true,
+            name: true,
+          },
         },
         skip: 0,
         limit: LIMIT_PER_PROJECT,
@@ -2531,6 +2703,8 @@ export default class StatusPageAPI extends BaseAPI<
       if (email) {
         const host: Hostname = await DatabaseConfig.getHost();
         const httpProtocol: Protocol = await DatabaseConfig.getHttpProtocol();
+        const statusPageIdString: string | null =
+          statusPage.id?.toString() || statusPage._id?.toString() || null;
 
         MailService.sendMail(
           {
@@ -2540,12 +2714,13 @@ export default class StatusPageAPI extends BaseAPI<
             vars: {
               statusPageName: statusPage.name || "Status Page",
               statusPageUrl: statusPageURL,
-              logoUrl: statusPage.logoFileId
-                ? new URL(httpProtocol, host)
-                    .addRoute(FileRoute)
-                    .addRoute("/image/" + statusPage.logoFileId)
-                    .toString()
-                : "",
+              logoUrl:
+                statusPage.logoFileId && statusPageIdString
+                  ? new URL(httpProtocol, host)
+                      .addRoute(StatusPageApiRoute)
+                      .addRoute(`/logo/${statusPageIdString}`)
+                      .toString()
+                  : "",
               isPublicStatusPage: statusPage.isPublicStatusPage
                 ? "true"
                 : "false",
@@ -3155,6 +3330,10 @@ export default class StatusPageAPI extends BaseAPI<
           postedAt: true,
           note: true,
           incidentId: true,
+          attachments: {
+            _id: true,
+            name: true,
+          },
         },
         sort: {
           postedAt: SortOrder.Descending, // new note first
@@ -3489,6 +3668,353 @@ export default class StatusPageAPI extends BaseAPI<
     };
   }
 
+  private async getStatusPageAnnouncementAttachment(
+    req: ExpressRequest,
+    res: ExpressResponse,
+  ): Promise<void> {
+    const statusPageIdParam: string | undefined = req.params["statusPageId"];
+    const announcementIdParam: string | undefined =
+      req.params["announcementId"];
+    const fileIdParam: string | undefined = req.params["fileId"];
+
+    if (!statusPageIdParam || !announcementIdParam || !fileIdParam) {
+      throw new NotFoundException("Attachment not found");
+    }
+
+    let statusPageId: ObjectID;
+    let announcementId: ObjectID;
+    let fileId: ObjectID;
+
+    try {
+      statusPageId = new ObjectID(statusPageIdParam);
+      announcementId = new ObjectID(announcementIdParam);
+      fileId = new ObjectID(fileIdParam);
+    } catch {
+      throw new NotFoundException("Attachment not found");
+    }
+
+    await this.checkHasReadAccess({
+      statusPageId: statusPageId,
+      req: req,
+    });
+
+    const statusPage: StatusPage | null = await StatusPageService.findOneBy({
+      query: {
+        _id: statusPageId.toString(),
+      },
+      select: {
+        _id: true,
+        projectId: true,
+        showAnnouncementsOnStatusPage: true,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    if (
+      !statusPage ||
+      !statusPage.projectId ||
+      !statusPage.showAnnouncementsOnStatusPage
+    ) {
+      throw new NotFoundException("Attachment not found");
+    }
+
+    const announcement: StatusPageAnnouncement | null =
+      await StatusPageAnnouncementService.findOneBy({
+        query: {
+          _id: announcementId.toString(),
+          projectId: statusPage.projectId!,
+          statusPages: [statusPageId] as any,
+        },
+        select: {
+          attachments: {
+            _id: true,
+            file: true,
+            fileType: true,
+            name: true,
+          },
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+    if (!announcement) {
+      throw new NotFoundException("Attachment not found");
+    }
+
+    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);
+  }
+
+  private async getScheduledMaintenancePublicNoteAttachment(
+    req: ExpressRequest,
+    res: ExpressResponse,
+  ): Promise<void> {
+    const statusPageIdParam: string | undefined = req.params["statusPageId"];
+    const scheduledMaintenanceIdParam: string | undefined =
+      req.params["scheduledMaintenanceId"];
+    const noteIdParam: string | undefined = req.params["noteId"];
+    const fileIdParam: string | undefined = req.params["fileId"];
+
+    if (
+      !statusPageIdParam ||
+      !scheduledMaintenanceIdParam ||
+      !noteIdParam ||
+      !fileIdParam
+    ) {
+      throw new NotFoundException("Attachment not found");
+    }
+
+    let statusPageId: ObjectID;
+    let scheduledMaintenanceId: ObjectID;
+    let noteId: ObjectID;
+    let fileId: ObjectID;
+
+    try {
+      statusPageId = new ObjectID(statusPageIdParam);
+      scheduledMaintenanceId = new ObjectID(scheduledMaintenanceIdParam);
+      noteId = new ObjectID(noteIdParam);
+      fileId = new ObjectID(fileIdParam);
+    } catch {
+      throw new NotFoundException("Attachment not found");
+    }
+
+    await this.checkHasReadAccess({
+      statusPageId: statusPageId,
+      req: req,
+    });
+
+    const statusPage: StatusPage | null = await StatusPageService.findOneBy({
+      query: {
+        _id: statusPageId.toString(),
+      },
+      select: {
+        _id: true,
+        projectId: true,
+        showScheduledMaintenanceEventsOnStatusPage: true,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    if (
+      !statusPage ||
+      !statusPage.projectId ||
+      !statusPage.showScheduledMaintenanceEventsOnStatusPage
+    ) {
+      throw new NotFoundException("Attachment not found");
+    }
+
+    const scheduledMaintenance: ScheduledMaintenance | null =
+      await ScheduledMaintenanceService.findOneBy({
+        query: {
+          _id: scheduledMaintenanceId.toString(),
+          projectId: statusPage.projectId!,
+          isVisibleOnStatusPage: true,
+          statusPages: statusPageId as any,
+        },
+        select: {
+          _id: true,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+    if (!scheduledMaintenance) {
+      throw new NotFoundException("Attachment not found");
+    }
+
+    const scheduledMaintenancePublicNote: ScheduledMaintenancePublicNote | null =
+      await ScheduledMaintenancePublicNoteService.findOneBy({
+        query: {
+          _id: noteId.toString(),
+          scheduledMaintenanceId: scheduledMaintenanceId.toString(),
+          projectId: statusPage.projectId!,
+        },
+        select: {
+          attachments: {
+            _id: true,
+            file: true,
+            fileType: true,
+            name: true,
+          },
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+    if (!scheduledMaintenancePublicNote) {
+      throw new NotFoundException("Attachment not found");
+    }
+
+    const attachment: File | undefined =
+      scheduledMaintenancePublicNote.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);
+  }
+
+  private async getIncidentPublicNoteAttachment(
+    req: ExpressRequest,
+    res: ExpressResponse,
+  ): Promise<void> {
+    const statusPageIdParam: string | undefined = req.params["statusPageId"];
+    const incidentIdParam: string | undefined = req.params["incidentId"];
+    const noteIdParam: string | undefined = req.params["noteId"];
+    const fileIdParam: string | undefined = req.params["fileId"];
+
+    if (
+      !statusPageIdParam ||
+      !incidentIdParam ||
+      !noteIdParam ||
+      !fileIdParam
+    ) {
+      throw new NotFoundException("Attachment not found");
+    }
+
+    let statusPageId: ObjectID;
+    let incidentId: ObjectID;
+    let noteId: ObjectID;
+    let fileId: ObjectID;
+
+    try {
+      statusPageId = new ObjectID(statusPageIdParam);
+      incidentId = new ObjectID(incidentIdParam);
+      noteId = new ObjectID(noteIdParam);
+      fileId = new ObjectID(fileIdParam);
+    } catch {
+      throw new NotFoundException("Attachment not found");
+    }
+
+    await this.checkHasReadAccess({
+      statusPageId: statusPageId,
+      req: req,
+    });
+
+    const statusPage: StatusPage | null = await StatusPageService.findOneBy({
+      query: {
+        _id: statusPageId.toString(),
+      },
+      select: {
+        _id: true,
+        projectId: true,
+        showIncidentsOnStatusPage: true,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    if (!statusPage || !statusPage.projectId) {
+      throw new NotFoundException("Attachment not found");
+    }
+
+    if (!statusPage.showIncidentsOnStatusPage) {
+      throw new NotFoundException("Attachment not found");
+    }
+
+    const { monitorsOnStatusPage } =
+      await StatusPageService.getMonitorIdsOnStatusPage({
+        statusPageId: statusPageId,
+      });
+
+    if (!monitorsOnStatusPage || monitorsOnStatusPage.length === 0) {
+      throw new NotFoundException("Attachment not found");
+    }
+
+    const incident: Incident | null = await IncidentService.findOneBy({
+      query: {
+        _id: incidentId.toString(),
+        projectId: statusPage.projectId!,
+        isVisibleOnStatusPage: true,
+        monitors: monitorsOnStatusPage as any,
+      },
+      select: {
+        _id: true,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    if (!incident) {
+      throw new NotFoundException("Attachment not found");
+    }
+
+    const incidentPublicNote: IncidentPublicNote | null =
+      await IncidentPublicNoteService.findOneBy({
+        query: {
+          _id: noteId.toString(),
+          incidentId: incidentId.toString(),
+          projectId: statusPage.projectId!,
+        },
+        select: {
+          attachments: {
+            _id: true,
+            file: true,
+            fileType: true,
+            name: true,
+          },
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+    if (!incidentPublicNote) {
+      throw new NotFoundException("Attachment not found");
+    }
+
+    const attachment: File | undefined = incidentPublicNote.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);
+  }
+
   public async checkHasReadAccess(data: {
     statusPageId: ObjectID;
     req: ExpressRequest;