@oneuptime/common 7.0.2936 → 7.0.2976

package/build/dist/Server/API/StatusPageAPI.js

@@ -0,0 +1,1558 @@
+import UserMiddleware from "../Middleware/UserAuthorization";
+import AcmeChallengeService from "../Services/AcmeChallengeService";
+import IncidentPublicNoteService from "../Services/IncidentPublicNoteService";
+import IncidentService from "../Services/IncidentService";
+import IncidentStateService from "../Services/IncidentStateService";
+import IncidentStateTimelineService from "../Services/IncidentStateTimelineService";
+import MonitorGroupResourceService from "../Services/MonitorGroupResourceService";
+import MonitorGroupService from "../Services/MonitorGroupService";
+import MonitorStatusService from "../Services/MonitorStatusService";
+import ScheduledMaintenancePublicNoteService from "../Services/ScheduledMaintenancePublicNoteService";
+import ScheduledMaintenanceService from "../Services/ScheduledMaintenanceService";
+import ScheduledMaintenanceStateService from "../Services/ScheduledMaintenanceStateService";
+import ScheduledMaintenanceStateTimelineService from "../Services/ScheduledMaintenanceStateTimelineService";
+import StatusPageAnnouncementService from "../Services/StatusPageAnnouncementService";
+import StatusPageDomainService from "../Services/StatusPageDomainService";
+import StatusPageFooterLinkService from "../Services/StatusPageFooterLinkService";
+import StatusPageGroupService from "../Services/StatusPageGroupService";
+import StatusPageHeaderLinkService from "../Services/StatusPageHeaderLinkService";
+import StatusPageHistoryChartBarColorRuleService from "../Services/StatusPageHistoryChartBarColorRuleService";
+import StatusPageResourceService from "../Services/StatusPageResourceService";
+import StatusPageService from "../Services/StatusPageService";
+import StatusPageSsoService from "../Services/StatusPageSsoService";
+import StatusPageSubscriberService from "../Services/StatusPageSubscriberService";
+import QueryHelper from "../Types/Database/QueryHelper";
+import logger from "../Utils/Logger";
+import Response from "../Utils/Response";
+import BaseAPI from "./BaseAPI";
+import CommonAPI from "./CommonAPI";
+import BaseModel from "Common/Models/DatabaseModels/DatabaseBaseModel/DatabaseBaseModel";
+import ArrayUtil from "Common/Types/ArrayUtil";
+import SortOrder from "Common/Types/BaseDatabase/SortOrder";
+import { LIMIT_PER_PROJECT } from "Common/Types/Database/LimitMax";
+import OneUptimeDate from "Common/Types/Date";
+import Email from "Common/Types/Email";
+import BadDataException from "Common/Types/Exception/BadDataException";
+import NotAuthenticatedException from "Common/Types/Exception/NotAuthenticatedException";
+import NotFoundException from "Common/Types/Exception/NotFoundException";
+import JSONFunctions from "Common/Types/JSONFunctions";
+import ObjectID from "Common/Types/ObjectID";
+import Phone from "Common/Types/Phone";
+import PositiveNumber from "Common/Types/PositiveNumber";
+import Incident from "Common/Models/DatabaseModels/Incident";
+import IncidentPublicNote from "Common/Models/DatabaseModels/IncidentPublicNote";
+import IncidentState from "Common/Models/DatabaseModels/IncidentState";
+import IncidentStateTimeline from "Common/Models/DatabaseModels/IncidentStateTimeline";
+import MonitorStatus from "Common/Models/DatabaseModels/MonitorStatus";
+import MonitorStatusTimeline from "Common/Models/DatabaseModels/MonitorStatusTimeline";
+import ScheduledMaintenance from "Common/Models/DatabaseModels/ScheduledMaintenance";
+import ScheduledMaintenancePublicNote from "Common/Models/DatabaseModels/ScheduledMaintenancePublicNote";
+import ScheduledMaintenanceState from "Common/Models/DatabaseModels/ScheduledMaintenanceState";
+import ScheduledMaintenanceStateTimeline from "Common/Models/DatabaseModels/ScheduledMaintenanceStateTimeline";
+import StatusPage from "Common/Models/DatabaseModels/StatusPage";
+import StatusPageAnnouncement from "Common/Models/DatabaseModels/StatusPageAnnouncement";
+import StatusPageFooterLink from "Common/Models/DatabaseModels/StatusPageFooterLink";
+import StatusPageGroup from "Common/Models/DatabaseModels/StatusPageGroup";
+import StatusPageHeaderLink from "Common/Models/DatabaseModels/StatusPageHeaderLink";
+import StatusPageHistoryChartBarColorRule from "Common/Models/DatabaseModels/StatusPageHistoryChartBarColorRule";
+import StatusPageResource from "Common/Models/DatabaseModels/StatusPageResource";
+import StatusPageSSO from "Common/Models/DatabaseModels/StatusPageSso";
+import StatusPageSubscriber from "Common/Models/DatabaseModels/StatusPageSubscriber";
+export default class StatusPageAPI extends BaseAPI {
+    constructor() {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s;
+        super(StatusPage, StatusPageService);
+        // CNAME verification api
+        this.router.get(`${(_a = new this.entityType()
+            .getCrudApiPath()) === null || _a === void 0 ? void 0 : _a.toString()}/cname-verification/:token`, async (req, res) => {
+            const host = req.get("host");
+            if (!host) {
+                throw new BadDataException("Host not found");
+            }
+            const token = req.params["token"];
+            logger.debug(`CNAME Verification: Host:${host}  - Token:${token}`);
+            const domain = await StatusPageDomainService.findOneBy({
+                query: {
+                    cnameVerificationToken: token,
+                    fullDomain: host,
+                },
+                select: {
+                    _id: true,
+                },
+                props: {
+                    isRoot: true,
+                },
+            });
+            if (!domain) {
+                return Response.sendErrorResponse(req, res, new BadDataException("Invalid token."));
+            }
+            return Response.sendEmptySuccessResponse(req, res);
+        });
+        // ACME Challenge Validation.
+        this.router.get(`${(_b = new this.entityType()
+            .getCrudApiPath()) === null || _b === void 0 ? void 0 : _b.toString()}/.well-known/acme-challenge/:token`, async (req, res) => {
+            const challenge = await AcmeChallengeService.findOneBy({
+                query: {
+                    token: req.params["token"],
+                },
+                select: {
+                    challenge: true,
+                },
+                props: {
+                    isRoot: true,
+                },
+            });
+            if (!challenge) {
+                return Response.sendErrorResponse(req, res, new NotFoundException("Challenge not found"));
+            }
+            return Response.sendTextResponse(req, res, challenge.challenge);
+        });
+        this.router.post(`${(_c = new this.entityType().getCrudApiPath()) === null || _c === void 0 ? void 0 : _c.toString()}/test-email-report`, UserMiddleware.getUserMiddleware, async (req, res, next) => {
+            try {
+                const email = new Email(req.body["email"]);
+                const statusPageId = new ObjectID(req.body["statusPageId"].toString());
+                await StatusPageService.sendEmailReport({
+                    email: email,
+                    statusPageId,
+                });
+                return Response.sendEmptySuccessResponse(req, res);
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        this.router.post(`${(_d = new this.entityType().getCrudApiPath()) === null || _d === void 0 ? void 0 : _d.toString()}/domain`, UserMiddleware.getUserMiddleware, async (req, res, next) => {
+            try {
+                if (!req.body["domain"]) {
+                    throw new BadDataException("domain is required in request body");
+                }
+                const domain = req.body["domain"];
+                const statusPageDomain = await StatusPageDomainService.findOneBy({
+                    query: {
+                        fullDomain: domain,
+                        domain: {
+                            isVerified: true,
+                        },
+                    },
+                    select: {
+                        statusPageId: true,
+                    },
+                    props: {
+                        isRoot: true,
+                    },
+                });
+                if (!statusPageDomain) {
+                    throw new BadDataException("No status page found with this domain");
+                }
+                const objectId = statusPageDomain.statusPageId;
+                return Response.sendJsonObjectResponse(req, res, {
+                    statusPageId: objectId.toString(),
+                });
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        this.router.post(`${(_e = new this.entityType()
+            .getCrudApiPath()) === null || _e === void 0 ? void 0 : _e.toString()}/master-page/:statusPageId`, UserMiddleware.getUserMiddleware, async (req, res, next) => {
+            try {
+                const objectId = new ObjectID(req.params["statusPageId"]);
+                const select = {
+                    _id: true,
+                    slug: true,
+                    coverImageFileId: true,
+                    logoFileId: true,
+                    pageTitle: true,
+                    pageDescription: true,
+                    copyrightText: true,
+                    customCSS: true,
+                    customJavaScript: true,
+                    hidePoweredByOneUptimeBranding: true,
+                    headerHTML: true,
+                    footerHTML: true,
+                    enableEmailSubscribers: true,
+                    enableSmsSubscribers: true,
+                    isPublicStatusPage: true,
+                    allowSubscribersToChooseResources: true,
+                    requireSsoForLogin: true,
+                    coverImageFile: {
+                        file: true,
+                        _id: true,
+                        type: true,
+                        name: true,
+                    },
+                    faviconFile: {
+                        file: true,
+                        _id: true,
+                        type: true,
+                        name: true,
+                    },
+                    logoFile: {
+                        file: true,
+                        _id: true,
+                        type: true,
+                        name: true,
+                    },
+                };
+                const hasEnabledSSO = await StatusPageSsoService.countBy({
+                    query: {
+                        isEnabled: true,
+                        statusPageId: objectId,
+                    },
+                    props: {
+                        isRoot: true,
+                    },
+                });
+                const item = await this.service.findOneById({
+                    id: objectId,
+                    select,
+                    props: {
+                        isRoot: true,
+                    },
+                });
+                if (!item) {
+                    throw new BadDataException("Status Page not found");
+                }
+                const footerLinks = await StatusPageFooterLinkService.findBy({
+                    query: {
+                        statusPageId: objectId,
+                    },
+                    select: {
+                        _id: true,
+                        link: true,
+                        title: true,
+                        order: true,
+                    },
+                    sort: {
+                        order: SortOrder.Ascending,
+                    },
+                    limit: LIMIT_PER_PROJECT,
+                    skip: 0,
+                    props: {
+                        isRoot: true,
+                    },
+                });
+                const headerLinks = await StatusPageHeaderLinkService.findBy({
+                    query: {
+                        statusPageId: objectId,
+                    },
+                    select: {
+                        _id: true,
+                        link: true,
+                        title: true,
+                        order: true,
+                    },
+                    sort: {
+                        order: SortOrder.Ascending,
+                    },
+                    limit: LIMIT_PER_PROJECT,
+                    skip: 0,
+                    props: {
+                        isRoot: true,
+                    },
+                });
+                const response = {
+                    statusPage: BaseModel.toJSON(item, StatusPage),
+                    footerLinks: BaseModel.toJSONArray(footerLinks, StatusPageFooterLink),
+                    headerLinks: BaseModel.toJSONArray(headerLinks, StatusPageHeaderLink),
+                    hasEnabledSSO: hasEnabledSSO.toNumber(),
+                };
+                return Response.sendJsonObjectResponse(req, res, response);
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        this.router.post(`${(_f = new this.entityType().getCrudApiPath()) === null || _f === void 0 ? void 0 : _f.toString()}/sso/:statusPageId`, UserMiddleware.getUserMiddleware, async (req, res, next) => {
+            try {
+                const objectId = new ObjectID(req.params["statusPageId"]);
+                const sso = await StatusPageSsoService.findBy({
+                    query: {
+                        statusPageId: objectId,
+                        isEnabled: true,
+                    },
+                    select: {
+                        signOnURL: true,
+                        name: true,
+                        description: true,
+                        _id: true,
+                    },
+                    limit: LIMIT_PER_PROJECT,
+                    skip: 0,
+                    props: {
+                        isRoot: true,
+                    },
+                });
+                return Response.sendEntityArrayResponse(req, res, sso, new PositiveNumber(sso.length), StatusPageSSO);
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        // Get all status page resources for subscriber to subscribe to.
+        this.router.post(`${(_g = new this.entityType()
+            .getCrudApiPath()) === null || _g === void 0 ? void 0 : _g.toString()}/resources/:statusPageId`, UserMiddleware.getUserMiddleware, async (req, res, next) => {
+            try {
+                const objectId = new ObjectID(req.params["statusPageId"]);
+                if (!(await this.service.hasReadAccess(objectId, await CommonAPI.getDatabaseCommonInteractionProps(req), req))) {
+                    throw new NotAuthenticatedException("You are not authenticated to access this status page");
+                }
+                const resources = await StatusPageResourceService.findBy({
+                    query: {
+                        statusPageId: objectId,
+                    },
+                    select: {
+                        _id: true,
+                        displayName: true,
+                        order: true,
+                        statusPageGroup: {
+                            _id: true,
+                            name: true,
+                            order: true,
+                        },
+                    },
+                    limit: LIMIT_PER_PROJECT,
+                    skip: 0,
+                    props: {
+                        isRoot: true,
+                    },
+                });
+                return Response.sendEntityArrayResponse(req, res, resources, new PositiveNumber(resources.length), StatusPageResource);
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        this.router.post(`${(_h = new this.entityType()
+            .getCrudApiPath()) === null || _h === void 0 ? void 0 : _h.toString()}/overview/:statusPageId`, UserMiddleware.getUserMiddleware, async (req, res, next) => {
+            try {
+                const objectId = new ObjectID(req.params["statusPageId"]);
+                if (!(await this.service.hasReadAccess(objectId, await CommonAPI.getDatabaseCommonInteractionProps(req), req))) {
+                    throw new NotAuthenticatedException("You are not authenticated to access this status page");
+                }
+                const statusPage = await StatusPageService.findOneBy({
+                    query: {
+                        _id: objectId.toString(),
+                    },
+                    select: {
+                        _id: true,
+                        projectId: true,
+                        isPublicStatusPage: true,
+                        overviewPageDescription: true,
+                        showIncidentLabelsOnStatusPage: true,
+                        showScheduledEventLabelsOnStatusPage: true,
+                        downtimeMonitorStatuses: {
+                            _id: true,
+                        },
+                        defaultBarColor: true,
+                        showOverallUptimePercentOnStatusPage: true,
+                        overallUptimePercentPrecision: true,
+                    },
+                    props: {
+                        isRoot: true,
+                    },
+                });
+                if (!statusPage) {
+                    throw new BadDataException("Status Page not found");
+                }
+                //get monitor statuses
+                const monitorStatuses = await MonitorStatusService.findBy({
+                    query: {
+                        projectId: statusPage.projectId,
+                    },
+                    select: {
+                        name: true,
+                        color: true,
+                        priority: true,
+                        isOperationalState: true,
+                    },
+                    sort: {
+                        priority: SortOrder.Ascending,
+                    },
+                    skip: 0,
+                    limit: LIMIT_PER_PROJECT,
+                    props: {
+                        isRoot: true,
+                    },
+                });
+                // get resource groups.
+                const groups = await StatusPageGroupService.findBy({
+                    query: {
+                        statusPageId: objectId,
+                    },
+                    select: {
+                        name: true,
+                        order: true,
+                        description: true,
+                        isExpandedByDefault: true,
+                    },
+                    sort: {
+                        order: SortOrder.Ascending,
+                    },
+                    skip: 0,
+                    limit: LIMIT_PER_PROJECT,
+                    props: {
+                        isRoot: true,
+                    },
+                });
+                // get monitors on status page.
+                const statusPageResources = await StatusPageResourceService.findBy({
+                    query: {
+                        statusPageId: objectId,
+                    },
+                    select: {
+                        statusPageGroupId: true,
+                        monitorId: true,
+                        displayTooltip: true,
+                        displayDescription: true,
+                        displayName: true,
+                        showStatusHistoryChart: true,
+                        showCurrentStatus: true,
+                        order: true,
+                        monitor: {
+                            _id: true,
+                            currentMonitorStatusId: true,
+                        },
+                        monitorGroupId: true,
+                        showUptimePercent: true,
+                        uptimePercentPrecision: true,
+                    },
+                    sort: {
+                        order: SortOrder.Ascending,
+                    },
+                    skip: 0,
+                    limit: LIMIT_PER_PROJECT,
+                    props: {
+                        isRoot: true,
+                    },
+                });
+                const monitorGroupIds = statusPageResources
+                    .map((resource) => {
+                    return resource.monitorGroupId;
+                })
+                    .filter((id) => {
+                    return Boolean(id); // remove nulls
+                });
+                // get monitors in the group.
+                const monitorGroupCurrentStatuses = {};
+                const monitorsInGroup = {};
+                // get monitor status charts.
+                const monitorsOnStatusPage = statusPageResources
+                    .map((monitor) => {
+                    return monitor.monitorId;
+                })
+                    .filter((id) => {
+                    return Boolean(id); // remove nulls
+                });
+                const monitorsOnStatusPageForTimeline = statusPageResources
+                    .filter((monitor) => {
+                    return (monitor.showStatusHistoryChart || monitor.showUptimePercent);
+                })
+                    .map((monitor) => {
+                    return monitor.monitorId;
+                })
+                    .filter((id) => {
+                    return Boolean(id); // remove nulls
+                });
+                for (const monitorGroupId of monitorGroupIds) {
+                    // get current status of monitors in the group.
+                    const currentStatus = await MonitorGroupService.getCurrentStatus(monitorGroupId, {
+                        isRoot: true,
+                    });
+                    monitorGroupCurrentStatuses[monitorGroupId.toString()] =
+                        currentStatus.id;
+                    // get monitors in the group.
+                    const groupResources = await MonitorGroupResourceService.findBy({
+                        query: {
+                            monitorGroupId: monitorGroupId,
+                        },
+                        select: {
+                            monitorId: true,
+                        },
+                        props: {
+                            isRoot: true,
+                        },
+                        limit: LIMIT_PER_PROJECT,
+                        skip: 0,
+                    });
+                    const monitorsInGroupIds = groupResources
+                        .map((resource) => {
+                        return resource.monitorId;
+                    })
+                        .filter((id) => {
+                        return Boolean(id); // remove nulls
+                    });
+                    const shouldShowTimelineForThisGroup = Boolean(statusPageResources.find((resource) => {
+                        var _a;
+                        return (((_a = resource.monitorGroupId) === null || _a === void 0 ? void 0 : _a.toString()) ===
+                            monitorGroupId.toString() &&
+                            (resource.showStatusHistoryChart ||
+                                resource.showUptimePercent));
+                    }));
+                    for (const monitorId of monitorsInGroupIds) {
+                        if (!monitorId) {
+                            continue;
+                        }
+                        if (!monitorsOnStatusPage.find((item) => {
+                            return item.toString() === monitorId.toString();
+                        })) {
+                            monitorsOnStatusPage.push(monitorId);
+                        }
+                        // add this to the timeline event for this group.
+                        if (shouldShowTimelineForThisGroup &&
+                            !monitorsOnStatusPageForTimeline.find((item) => {
+                                return item.toString() === monitorId.toString();
+                            })) {
+                            monitorsOnStatusPageForTimeline.push(monitorId);
+                        }
+                    }
+                    monitorsInGroup[monitorGroupId.toString()] = monitorsInGroupIds;
+                }
+                const monitorStatusTimelines = await StatusPageService.getMonitorStatusTimelineForStatusPage({
+                    monitorIds: monitorsOnStatusPageForTimeline,
+                    historyDays: 90,
+                });
+                // check if status page has active incident.
+                let activeIncidents = [];
+                if (monitorsOnStatusPage.length > 0) {
+                    let select = {
+                        createdAt: true,
+                        title: true,
+                        description: true,
+                        _id: true,
+                        incidentSeverity: {
+                            name: true,
+                            color: true,
+                        },
+                        currentIncidentState: {
+                            _id: true,
+                            name: true,
+                            color: true,
+                            order: true,
+                        },
+                        monitors: {
+                            _id: true,
+                        },
+                    };
+                    if (statusPage.showIncidentLabelsOnStatusPage) {
+                        select = Object.assign(Object.assign({}, select), { labels: {
+                                name: true,
+                                color: true,
+                            } });
+                    }
+                    const unresolvedIncidentStates = await IncidentStateService.getUnresolvedIncidentStates(statusPage.projectId, {
+                        isRoot: true,
+                    });
+                    const unresolvedIncidentStateIds = unresolvedIncidentStates.map((state) => {
+                        return state.id;
+                    });
+                    activeIncidents = await IncidentService.findBy({
+                        query: {
+                            monitors: monitorsOnStatusPage,
+                            currentIncidentStateId: QueryHelper.any(unresolvedIncidentStateIds),
+                            projectId: statusPage.projectId,
+                        },
+                        select: select,
+                        sort: {
+                            createdAt: SortOrder.Ascending,
+                        },
+                        skip: 0,
+                        limit: LIMIT_PER_PROJECT,
+                        props: {
+                            isRoot: true,
+                        },
+                    });
+                }
+                const incidentsOnStatusPage = activeIncidents.map((incident) => {
+                    return incident.id;
+                });
+                let incidentPublicNotes = [];
+                if (incidentsOnStatusPage.length > 0) {
+                    incidentPublicNotes = await IncidentPublicNoteService.findBy({
+                        query: {
+                            incidentId: QueryHelper.any(incidentsOnStatusPage),
+                            projectId: statusPage.projectId,
+                        },
+                        select: {
+                            note: true,
+                            incidentId: true,
+                            postedAt: true,
+                        },
+                        sort: {
+                            postedAt: SortOrder.Descending, // new note first
+                        },
+                        skip: 0,
+                        limit: LIMIT_PER_PROJECT,
+                        props: {
+                            isRoot: true,
+                        },
+                    });
+                }
+                let incidentStateTimelines = [];
+                if (incidentsOnStatusPage.length > 0) {
+                    incidentStateTimelines = await IncidentStateTimelineService.findBy({
+                        query: {
+                            incidentId: QueryHelper.any(incidentsOnStatusPage),
+                            projectId: statusPage.projectId,
+                        },
+                        select: {
+                            _id: true,
+                            createdAt: true,
+                            incidentId: true,
+                            incidentState: {
+                                _id: true,
+                                name: true,
+                                color: true,
+                                isCreatedState: true,
+                                isResolvedState: true,
+                                isAcknowledgedState: true,
+                            },
+                        },
+                        sort: {
+                            createdAt: SortOrder.Descending, // new note first
+                        },
+                        skip: 0,
+                        limit: LIMIT_PER_PROJECT,
+                        props: {
+                            isRoot: true,
+                        },
+                    });
+                }
+                // check if status page has active announcement.
+                const today = OneUptimeDate.getCurrentDate();
+                const activeAnnouncements = await StatusPageAnnouncementService.findBy({
+                    query: {
+                        statusPages: objectId,
+                        showAnnouncementAt: QueryHelper.lessThan(today),
+                        endAnnouncementAt: QueryHelper.greaterThan(today),
+                        projectId: statusPage.projectId,
+                    },
+                    select: {
+                        createdAt: true,
+                        title: true,
+                        description: true,
+                        _id: true,
+                        showAnnouncementAt: true,
+                        endAnnouncementAt: true,
+                    },
+                    skip: 0,
+                    limit: LIMIT_PER_PROJECT,
+                    props: {
+                        isRoot: true,
+                    },
+                });
+                // check if status page has active scheduled events.
+                let scheduledEventsSelect = {
+                    createdAt: true,
+                    title: true,
+                    description: true,
+                    _id: true,
+                    endsAt: true,
+                    startsAt: true,
+                    currentScheduledMaintenanceState: {
+                        name: true,
+                        color: true,
+                        isScheduledState: true,
+                        isResolvedState: true,
+                        isOngoingState: true,
+                    },
+                    monitors: {
+                        _id: true,
+                    },
+                };
+                if (statusPage.showScheduledEventLabelsOnStatusPage) {
+                    scheduledEventsSelect = Object.assign(Object.assign({}, scheduledEventsSelect), { labels: {
+                            name: true,
+                            color: true,
+                        } });
+                }
+                const scheduledMaintenanceEvents = await ScheduledMaintenanceService.findBy({
+                    query: {
+                        currentScheduledMaintenanceState: {
+                            isOngoingState: true,
+                        },
+                        statusPages: objectId,
+                        projectId: statusPage.projectId,
+                    },
+                    select: scheduledEventsSelect,
+                    sort: {
+                        startsAt: SortOrder.Ascending,
+                    },
+                    skip: 0,
+                    limit: LIMIT_PER_PROJECT,
+                    props: {
+                        isRoot: true,
+                    },
+                });
+                const futureScheduledMaintenanceEvents = await ScheduledMaintenanceService.findBy({
+                    query: {
+                        currentScheduledMaintenanceState: {
+                            isScheduledState: true,
+                        },
+                        statusPages: objectId,
+                        projectId: statusPage.projectId,
+                    },
+                    select: scheduledEventsSelect,
+                    sort: {
+                        startsAt: SortOrder.Ascending,
+                    },
+                    skip: 0,
+                    limit: LIMIT_PER_PROJECT,
+                    props: {
+                        isRoot: true,
+                    },
+                });
+                futureScheduledMaintenanceEvents.forEach((event) => {
+                    scheduledMaintenanceEvents.push(event);
+                });
+                const scheduledMaintenanceEventsOnStatusPage = scheduledMaintenanceEvents.map((event) => {
+                    return event.id;
+                });
+                let scheduledMaintenanceEventsPublicNotes = [];
+                if (scheduledMaintenanceEventsOnStatusPage.length > 0) {
+                    scheduledMaintenanceEventsPublicNotes =
+                        await ScheduledMaintenancePublicNoteService.findBy({
+                            query: {
+                                scheduledMaintenanceId: QueryHelper.any(scheduledMaintenanceEventsOnStatusPage),
+                                projectId: statusPage.projectId,
+                            },
+                            select: {
+                                postedAt: true,
+                                note: true,
+                                scheduledMaintenanceId: true,
+                            },
+                            sort: {
+                                postedAt: SortOrder.Ascending,
+                            },
+                            skip: 0,
+                            limit: LIMIT_PER_PROJECT,
+                            props: {
+                                isRoot: true,
+                            },
+                        });
+                }
+                let scheduledMaintenanceStateTimelines = [];
+                if (scheduledMaintenanceEventsOnStatusPage.length > 0) {
+                    scheduledMaintenanceStateTimelines =
+                        await ScheduledMaintenanceStateTimelineService.findBy({
+                            query: {
+                                scheduledMaintenanceId: QueryHelper.any(scheduledMaintenanceEventsOnStatusPage),
+                                projectId: statusPage.projectId,
+                            },
+                            select: {
+                                _id: true,
+                                createdAt: true,
+                                scheduledMaintenanceId: true,
+                                scheduledMaintenanceState: {
+                                    _id: true,
+                                    color: true,
+                                    name: true,
+                                    isScheduledState: true,
+                                    isResolvedState: true,
+                                    isOngoingState: true,
+                                },
+                            },
+                            sort: {
+                                createdAt: SortOrder.Descending, // new note first
+                            },
+                            skip: 0,
+                            limit: LIMIT_PER_PROJECT,
+                            props: {
+                                isRoot: true,
+                            },
+                        });
+                }
+                // get all status page bar chart rules
+                const statusPageHistoryChartBarColorRules = await StatusPageHistoryChartBarColorRuleService.findBy({
+                    query: {
+                        statusPageId: objectId,
+                    },
+                    select: {
+                        _id: true,
+                        barColor: true,
+                        order: true,
+                        statusPageId: true,
+                        uptimePercentGreaterThanOrEqualTo: true,
+                    },
+                    sort: {
+                        order: SortOrder.Ascending,
+                    },
+                    skip: 0,
+                    limit: LIMIT_PER_PROJECT,
+                    props: {
+                        isRoot: true,
+                    },
+                });
+                const response = {
+                    scheduledMaintenanceEventsPublicNotes: BaseModel.toJSONArray(scheduledMaintenanceEventsPublicNotes, ScheduledMaintenancePublicNote),
+                    statusPageHistoryChartBarColorRules: BaseModel.toJSONArray(statusPageHistoryChartBarColorRules, StatusPageHistoryChartBarColorRule),
+                    scheduledMaintenanceEvents: BaseModel.toJSONArray(scheduledMaintenanceEvents, ScheduledMaintenance),
+                    activeAnnouncements: BaseModel.toJSONArray(activeAnnouncements, StatusPageAnnouncement),
+                    incidentPublicNotes: BaseModel.toJSONArray(incidentPublicNotes, IncidentPublicNote),
+                    activeIncidents: BaseModel.toJSONArray(activeIncidents, Incident),
+                    monitorStatusTimelines: BaseModel.toJSONArray(monitorStatusTimelines, MonitorStatusTimeline),
+                    resourceGroups: BaseModel.toJSONArray(groups, StatusPageGroup),
+                    monitorStatuses: BaseModel.toJSONArray(monitorStatuses, MonitorStatus),
+                    statusPageResources: BaseModel.toJSONArray(statusPageResources, StatusPageResource),
+                    incidentStateTimelines: BaseModel.toJSONArray(incidentStateTimelines, IncidentStateTimeline),
+                    statusPage: BaseModel.toJSONObject(statusPage, StatusPage),
+                    scheduledMaintenanceStateTimelines: BaseModel.toJSONArray(scheduledMaintenanceStateTimelines, ScheduledMaintenanceStateTimeline),
+                    monitorGroupCurrentStatuses: JSONFunctions.serialize(monitorGroupCurrentStatuses),
+                    monitorsInGroup: JSONFunctions.serialize(monitorsInGroup),
+                };
+                return Response.sendJsonObjectResponse(req, res, response);
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        this.router.put(`${(_j = new this.entityType()
+            .getCrudApiPath()) === null || _j === void 0 ? void 0 : _j.toString()}/update-subscription/:statusPageId/:subscriberId`, UserMiddleware.getUserMiddleware, async (req, res, next) => {
+            try {
+                await this.subscribeToStatusPage(req);
+                return Response.sendEmptySuccessResponse(req, res);
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        this.router.post(`${(_k = new this.entityType()
+            .getCrudApiPath()) === null || _k === void 0 ? void 0 : _k.toString()}/get-subscription/:statusPageId/:subscriberId`, UserMiddleware.getUserMiddleware, async (req, res, next) => {
+            try {
+                const subscriber = await this.getSubscriber(req);
+                return Response.sendEntityResponse(req, res, subscriber, StatusPageSubscriber);
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        this.router.post(`${(_l = new this.entityType()
+            .getCrudApiPath()) === null || _l === void 0 ? void 0 : _l.toString()}/subscribe/:statusPageId`, UserMiddleware.getUserMiddleware, async (req, res, next) => {
+            try {
+                await this.subscribeToStatusPage(req);
+                return Response.sendEmptySuccessResponse(req, res);
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        this.router.post(`${(_m = new this.entityType()
+            .getCrudApiPath()) === null || _m === void 0 ? void 0 : _m.toString()}/incidents/:statusPageId`, UserMiddleware.getUserMiddleware, async (req, res, next) => {
+            try {
+                const objectId = new ObjectID(req.params["statusPageId"]);
+                const response = await this.getIncidents(objectId, null, await CommonAPI.getDatabaseCommonInteractionProps(req), req);
+                return Response.sendJsonObjectResponse(req, res, response);
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        this.router.post(`${(_o = new this.entityType()
+            .getCrudApiPath()) === null || _o === void 0 ? void 0 : _o.toString()}/scheduled-maintenance-events/:statusPageId`, UserMiddleware.getUserMiddleware, async (req, res, next) => {
+            try {
+                const objectId = new ObjectID(req.params["statusPageId"]);
+                const response = await this.getScheduledMaintenanceEvents(objectId, null, await CommonAPI.getDatabaseCommonInteractionProps(req), req);
+                return Response.sendJsonObjectResponse(req, res, response);
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        this.router.post(`${(_p = new this.entityType()
+            .getCrudApiPath()) === null || _p === void 0 ? void 0 : _p.toString()}/announcements/:statusPageId`, UserMiddleware.getUserMiddleware, async (req, res, next) => {
+            try {
+                const objectId = new ObjectID(req.params["statusPageId"]);
+                const response = await this.getAnnouncements(objectId, null, await CommonAPI.getDatabaseCommonInteractionProps(req), req);
+                return Response.sendJsonObjectResponse(req, res, response);
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        this.router.post(`${(_q = new this.entityType()
+            .getCrudApiPath()) === null || _q === void 0 ? void 0 : _q.toString()}/incidents/:statusPageId/:incidentId`, UserMiddleware.getUserMiddleware, async (req, res, next) => {
+            try {
+                const objectId = new ObjectID(req.params["statusPageId"]);
+                const incidentId = new ObjectID(req.params["incidentId"]);
+                const response = await this.getIncidents(objectId, incidentId, await CommonAPI.getDatabaseCommonInteractionProps(req), req);
+                return Response.sendJsonObjectResponse(req, res, response);
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        this.router.post(`${(_r = new this.entityType()
+            .getCrudApiPath()) === null || _r === void 0 ? void 0 : _r.toString()}/scheduled-maintenance-events/:statusPageId/:scheduledMaintenanceId`, UserMiddleware.getUserMiddleware, async (req, res, next) => {
+            try {
+                const objectId = new ObjectID(req.params["statusPageId"]);
+                const scheduledMaintenanceId = new ObjectID(req.params["scheduledMaintenanceId"]);
+                const response = await this.getScheduledMaintenanceEvents(objectId, scheduledMaintenanceId, await CommonAPI.getDatabaseCommonInteractionProps(req), req);
+                return Response.sendJsonObjectResponse(req, res, response);
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        this.router.post(`${(_s = new this.entityType()
+            .getCrudApiPath()) === null || _s === void 0 ? void 0 : _s.toString()}/announcements/:statusPageId/:announcementId`, UserMiddleware.getUserMiddleware, async (req, res, next) => {
+            try {
+                const objectId = new ObjectID(req.params["statusPageId"]);
+                const announcementId = new ObjectID(req.params["announcementId"]);
+                const response = await this.getAnnouncements(objectId, announcementId, await CommonAPI.getDatabaseCommonInteractionProps(req), req);
+                return Response.sendJsonObjectResponse(req, res, response);
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+    }
+    async getScheduledMaintenanceEvents(statusPageId, scheduledMaintenanceId, props, req) {
+        if (!(await this.service.hasReadAccess(statusPageId, props, req))) {
+            throw new NotAuthenticatedException("You are not authenticated to access this status page");
+        }
+        const statusPage = await StatusPageService.findOneBy({
+            query: {
+                _id: statusPageId.toString(),
+            },
+            select: {
+                _id: true,
+                projectId: true,
+                showScheduledEventHistoryInDays: true,
+                showScheduledEventLabelsOnStatusPage: true,
+            },
+            props: {
+                isRoot: true,
+            },
+        });
+        if (!statusPage) {
+            throw new BadDataException("Status Page not found");
+        }
+        // get monitors on status page.
+        const statusPageResources = await StatusPageService.getStatusPageResources({
+            statusPageId: statusPageId,
+        });
+        // check if status page has active scheduled events.
+        const today = OneUptimeDate.getCurrentDate();
+        const historyDays = OneUptimeDate.getSomeDaysAgo(statusPage.showScheduledEventHistoryInDays || 14);
+        let query = {
+            startsAt: QueryHelper.inBetween(historyDays, today),
+            statusPages: [statusPageId],
+            projectId: statusPage.projectId,
+        };
+        if (scheduledMaintenanceId) {
+            query = {
+                _id: scheduledMaintenanceId.toString(),
+                statusPages: [statusPageId],
+                projectId: statusPage.projectId,
+            };
+        }
+        let scheduledEventsSelect = {
+            createdAt: true,
+            title: true,
+            description: true,
+            _id: true,
+            endsAt: true,
+            startsAt: true,
+            currentScheduledMaintenanceState: {
+                name: true,
+                color: true,
+                isScheduledState: true,
+                isResolvedState: true,
+                isOngoingState: true,
+                order: true,
+            },
+            monitors: {
+                _id: true,
+            },
+        };
+        if (statusPage.showScheduledEventLabelsOnStatusPage) {
+            scheduledEventsSelect = Object.assign(Object.assign({}, scheduledEventsSelect), { labels: {
+                    name: true,
+                    color: true,
+                } });
+        }
+        const scheduledMaintenanceEvents = await ScheduledMaintenanceService.findBy({
+            query: query,
+            select: scheduledEventsSelect,
+            sort: {
+                startsAt: SortOrder.Descending,
+            },
+            skip: 0,
+            limit: LIMIT_PER_PROJECT,
+            props: {
+                isRoot: true,
+            },
+        });
+        let futureScheduledMaintenanceEvents = [];
+        // If there is no scheduledMaintenanceId, then fetch all future scheduled events.
+        if (!scheduledMaintenanceId) {
+            futureScheduledMaintenanceEvents =
+                await ScheduledMaintenanceService.findBy({
+                    query: {
+                        currentScheduledMaintenanceState: {
+                            isScheduledState: true,
+                        },
+                        statusPages: [statusPageId],
+                        projectId: statusPage.projectId,
+                    },
+                    select: scheduledEventsSelect,
+                    sort: {
+                        createdAt: SortOrder.Ascending,
+                    },
+                    skip: 0,
+                    limit: LIMIT_PER_PROJECT,
+                    props: {
+                        isRoot: true,
+                    },
+                });
+            futureScheduledMaintenanceEvents.forEach((event) => {
+                scheduledMaintenanceEvents.push(event);
+            });
+        }
+        const scheduledMaintenanceEventsOnStatusPage = scheduledMaintenanceEvents.map((event) => {
+            return event.id;
+        });
+        let scheduledMaintenanceEventsPublicNotes = [];
+        if (scheduledMaintenanceEventsOnStatusPage.length > 0) {
+            scheduledMaintenanceEventsPublicNotes =
+                await ScheduledMaintenancePublicNoteService.findBy({
+                    query: {
+                        scheduledMaintenanceId: QueryHelper.any(scheduledMaintenanceEventsOnStatusPage),
+                        projectId: statusPage.projectId,
+                    },
+                    select: {
+                        postedAt: true,
+                        note: true,
+                        scheduledMaintenanceId: true,
+                    },
+                    sort: {
+                        postedAt: SortOrder.Ascending,
+                    },
+                    skip: 0,
+                    limit: LIMIT_PER_PROJECT,
+                    props: {
+                        isRoot: true,
+                    },
+                });
+        }
+        let scheduledMaintenanceStateTimelines = [];
+        if (scheduledMaintenanceEventsOnStatusPage.length > 0) {
+            scheduledMaintenanceStateTimelines =
+                await ScheduledMaintenanceStateTimelineService.findBy({
+                    query: {
+                        scheduledMaintenanceId: QueryHelper.any(scheduledMaintenanceEventsOnStatusPage),
+                        projectId: statusPage.projectId,
+                    },
+                    select: {
+                        _id: true,
+                        createdAt: true,
+                        scheduledMaintenanceId: true,
+                        scheduledMaintenanceState: {
+                            name: true,
+                            color: true,
+                            isScheduledState: true,
+                            isResolvedState: true,
+                            isOngoingState: true,
+                        },
+                    },
+                    sort: {
+                        createdAt: SortOrder.Descending, // new note first
+                    },
+                    skip: 0,
+                    limit: LIMIT_PER_PROJECT,
+                    props: {
+                        isRoot: true,
+                    },
+                });
+        }
+        const monitorGroupIds = statusPageResources
+            .map((resource) => {
+            return resource.monitorGroupId;
+        })
+            .filter((id) => {
+            return Boolean(id); // remove nulls
+        });
+        // get monitors in the group.
+        const monitorsInGroup = {};
+        // get monitor status charts.
+        const monitorsOnStatusPage = statusPageResources
+            .map((monitor) => {
+            return monitor.monitorId;
+        })
+            .filter((id) => {
+            return Boolean(id); // remove nulls
+        });
+        for (const monitorGroupId of monitorGroupIds) {
+            // get monitors in the group.
+            const groupResources = await MonitorGroupResourceService.findBy({
+                query: {
+                    monitorGroupId: monitorGroupId,
+                },
+                select: {
+                    monitorId: true,
+                },
+                props: {
+                    isRoot: true,
+                },
+                limit: LIMIT_PER_PROJECT,
+                skip: 0,
+            });
+            const monitorsInGroupIds = groupResources
+                .map((resource) => {
+                return resource.monitorId;
+            })
+                .filter((id) => {
+                return Boolean(id); // remove nulls
+            });
+            for (const monitorId of monitorsInGroupIds) {
+                if (!monitorsOnStatusPage.find((item) => {
+                    return item.toString() === monitorId.toString();
+                })) {
+                    monitorsOnStatusPage.push(monitorId);
+                }
+            }
+            monitorsInGroup[monitorGroupId.toString()] = monitorsInGroupIds;
+        }
+        // get scheduled event states.
+        const scheduledEventStates = await ScheduledMaintenanceStateService.findBy({
+            query: {
+                projectId: statusPage.projectId,
+            },
+            limit: LIMIT_PER_PROJECT,
+            skip: 0,
+            props: {
+                isRoot: true,
+            },
+            select: {
+                _id: true,
+                order: true,
+                isEndedState: true,
+                isOngoingState: true,
+                isScheduledState: true,
+            },
+        });
+        const response = {
+            scheduledMaintenanceEventsPublicNotes: BaseModel.toJSONArray(scheduledMaintenanceEventsPublicNotes, ScheduledMaintenancePublicNote),
+            scheduledMaintenanceStates: BaseModel.toJSONArray(scheduledEventStates, ScheduledMaintenanceState),
+            scheduledMaintenanceEvents: BaseModel.toJSONArray(scheduledMaintenanceEvents, ScheduledMaintenance),
+            statusPageResources: BaseModel.toJSONArray(statusPageResources, StatusPageResource),
+            scheduledMaintenanceStateTimelines: BaseModel.toJSONArray(scheduledMaintenanceStateTimelines, ScheduledMaintenanceStateTimeline),
+            monitorsInGroup: JSONFunctions.serialize(monitorsInGroup),
+        };
+        return response;
+    }
+    async getAnnouncements(statusPageId, announcementId, props, req) {
+        if (!(await this.service.hasReadAccess(statusPageId, props, req))) {
+            throw new NotAuthenticatedException("You are not authenticated to access this status page");
+        }
+        const statusPage = await StatusPageService.findOneBy({
+            query: {
+                _id: statusPageId.toString(),
+            },
+            select: {
+                _id: true,
+                projectId: true,
+                showAnnouncementHistoryInDays: true,
+            },
+            props: {
+                isRoot: true,
+            },
+        });
+        if (!statusPage) {
+            throw new BadDataException("Status Page not found");
+        }
+        // check if status page has active announcement.
+        const today = OneUptimeDate.getCurrentDate();
+        const historyDays = OneUptimeDate.getSomeDaysAgo(statusPage.showAnnouncementHistoryInDays || 14);
+        let query = {
+            statusPages: [statusPageId],
+            showAnnouncementAt: QueryHelper.inBetween(historyDays, today),
+            projectId: statusPage.projectId,
+        };
+        if (announcementId) {
+            query = {
+                statusPages: [statusPageId],
+                _id: announcementId.toString(),
+                projectId: statusPage.projectId,
+            };
+        }
+        const announcements = await StatusPageAnnouncementService.findBy({
+            query: query,
+            select: {
+                createdAt: true,
+                title: true,
+                description: true,
+                _id: true,
+                showAnnouncementAt: true,
+                endAnnouncementAt: true,
+            },
+            skip: 0,
+            limit: LIMIT_PER_PROJECT,
+            props: {
+                isRoot: true,
+            },
+        });
+        // get monitors on status page.
+        const statusPageResources = await StatusPageResourceService.findBy({
+            query: {
+                statusPageId: statusPageId,
+            },
+            select: {
+                statusPageGroupId: true,
+                monitorId: true,
+                displayTooltip: true,
+                displayDescription: true,
+                displayName: true,
+                monitor: {
+                    _id: true,
+                    currentMonitorStatusId: true,
+                },
+            },
+            skip: 0,
+            limit: LIMIT_PER_PROJECT,
+            props: {
+                isRoot: true,
+            },
+        });
+        const response = {
+            announcements: BaseModel.toJSONArray(announcements, StatusPageAnnouncement),
+            statusPageResources: BaseModel.toJSONArray(statusPageResources, StatusPageResource),
+        };
+        return response;
+    }
+    async subscribeToStatusPage(req) {
+        const objectId = new ObjectID(req.params["statusPageId"]);
+        if (!(await this.service.hasReadAccess(objectId, await CommonAPI.getDatabaseCommonInteractionProps(req), req))) {
+            throw new NotAuthenticatedException("You are not authenticated to access this status page");
+        }
+        const statusPage = await StatusPageService.findOneBy({
+            query: {
+                _id: objectId.toString(),
+            },
+            select: {
+                _id: true,
+                projectId: true,
+                enableEmailSubscribers: true,
+                enableSmsSubscribers: true,
+                allowSubscribersToChooseResources: true,
+            },
+            props: {
+                isRoot: true,
+            },
+        });
+        if (!statusPage) {
+            throw new BadDataException("Status Page not found");
+        }
+        if (req.body.data["subscriberEmail"] &&
+            !statusPage.enableEmailSubscribers) {
+            throw new BadDataException("Email subscribers not enabled for this status page.");
+        }
+        if (req.body.data["subscriberPhone"] && !statusPage.enableSmsSubscribers) {
+            throw new BadDataException("SMS subscribers not enabled for this status page.");
+        }
+        // if no email or phone, throw error.
+        if (!req.body.data["subscriberEmail"] &&
+            !req.body.data["subscriberPhone"]) {
+            throw new BadDataException("Email or phone is required to subscribe to this status page.");
+        }
+        const email = req.body.data["subscriberEmail"]
+            ? new Email(req.body.data["subscriberEmail"])
+            : undefined;
+        const phone = req.body.data["subscriberPhone"]
+            ? new Phone(req.body.data["subscriberPhone"])
+            : undefined;
+        let statusPageSubscriber = null;
+        let isUpdate = false;
+        if (!req.params["subscriberId"]) {
+            statusPageSubscriber = new StatusPageSubscriber();
+        }
+        else {
+            const subscriberId = new ObjectID(req.params["subscriberId"]);
+            statusPageSubscriber = await StatusPageSubscriberService.findOneBy({
+                query: {
+                    _id: subscriberId.toString(),
+                },
+                props: {
+                    isRoot: true,
+                },
+            });
+            if (!statusPageSubscriber) {
+                throw new BadDataException("Subscriber not found");
+            }
+            isUpdate = true;
+        }
+        if (email) {
+            statusPageSubscriber.subscriberEmail = email;
+        }
+        if (phone) {
+            statusPageSubscriber.subscriberPhone = phone;
+        }
+        if (req.body.data["statusPageResources"] &&
+            !statusPage.allowSubscribersToChooseResources) {
+            throw new BadDataException("Subscribers are not allowed to choose resources for this status page.");
+        }
+        statusPageSubscriber.statusPageId = objectId;
+        statusPageSubscriber.sendYouHaveSubscribedMessage = true;
+        statusPageSubscriber.projectId = statusPage.projectId;
+        statusPageSubscriber.isSubscribedToAllResources = Boolean(req.body.data["isSubscribedToAllResources"]);
+        if (req.body.data["statusPageResources"] &&
+            req.body.data["statusPageResources"].length > 0) {
+            statusPageSubscriber.statusPageResources = req.body.data["statusPageResources"];
+        }
+        if (isUpdate) {
+            // check isUnsubscribed is set to false.
+            statusPageSubscriber.isUnsubscribed = Boolean(req.body.data["isUnsubscribed"]);
+            await StatusPageSubscriberService.updateOneById({
+                id: statusPageSubscriber.id,
+                data: {
+                    statusPageResources: statusPageSubscriber.statusPageResources,
+                    isSubscribedToAllResources: statusPageSubscriber.isSubscribedToAllResources,
+                    isUnsubscribed: statusPageSubscriber.isUnsubscribed,
+                },
+                props: {
+                    isRoot: true,
+                },
+            });
+        }
+        else {
+            await StatusPageSubscriberService.create({
+                data: statusPageSubscriber,
+                props: {
+                    isRoot: true,
+                },
+            });
+        }
+    }
+    async getSubscriber(req) {
+        const objectId = new ObjectID(req.params["statusPageId"]);
+        if (!(await this.service.hasReadAccess(objectId, await CommonAPI.getDatabaseCommonInteractionProps(req), req))) {
+            throw new NotAuthenticatedException("You are not authenticated to access this status page");
+        }
+        const statusPage = await StatusPageService.findOneBy({
+            query: {
+                _id: objectId.toString(),
+            },
+            select: {
+                _id: true,
+                projectId: true,
+            },
+            props: {
+                isRoot: true,
+            },
+        });
+        if (!statusPage) {
+            throw new BadDataException("Status Page not found");
+        }
+        const subscriberId = new ObjectID(req.params["subscriberId"]);
+        const statusPageSubscriber = await StatusPageSubscriberService.findOneBy({
+            query: {
+                _id: subscriberId.toString(),
+                statusPageId: statusPage.id,
+            },
+            select: {
+                isUnsubscribed: true,
+                subscriberEmail: true,
+                subscriberPhone: true,
+                statusPageId: true,
+                statusPageResources: true,
+                isSubscribedToAllResources: true,
+            },
+            props: {
+                isRoot: true,
+            },
+        });
+        if (!statusPageSubscriber) {
+            throw new BadDataException("Subscriber not found");
+        }
+        return statusPageSubscriber;
+    }
+    async getIncidents(statusPageId, incidentId, props, req) {
+        if (!(await this.service.hasReadAccess(statusPageId, props, req))) {
+            throw new NotAuthenticatedException("You are not authenticated to access this status page");
+        }
+        const statusPage = await StatusPageService.findOneBy({
+            query: {
+                _id: statusPageId.toString(),
+            },
+            select: {
+                _id: true,
+                projectId: true,
+                showIncidentHistoryInDays: true,
+                showIncidentLabelsOnStatusPage: true,
+            },
+            props: {
+                isRoot: true,
+            },
+        });
+        if (!statusPage) {
+            throw new BadDataException("Status Page not found");
+        }
+        // get monitors on status page.
+        const statusPageResources = await StatusPageService.getStatusPageResources({
+            statusPageId: statusPageId,
+        });
+        const { monitorsOnStatusPage, monitorsInGroup } = await StatusPageService.getMonitorIdsOnStatusPage({
+            statusPageId: statusPageId,
+        });
+        const today = OneUptimeDate.getCurrentDate();
+        const historyDays = OneUptimeDate.getSomeDaysAgo(statusPage.showIncidentHistoryInDays || 14);
+        let incidentQuery = {
+            monitors: monitorsOnStatusPage,
+            projectId: statusPage.projectId,
+            createdAt: QueryHelper.inBetween(historyDays, today),
+        };
+        if (incidentId) {
+            incidentQuery = {
+                monitors: monitorsOnStatusPage,
+                projectId: statusPage.projectId,
+                _id: incidentId.toString(),
+            };
+        }
+        // check if status page has active incident.
+        let incidents = [];
+        let selectIncidents = {
+            createdAt: true,
+            title: true,
+            description: true,
+            _id: true,
+            incidentSeverity: {
+                name: true,
+                color: true,
+            },
+            currentIncidentState: {
+                name: true,
+                color: true,
+                _id: true,
+                order: true,
+            },
+            monitors: {
+                _id: true,
+            },
+        };
+        if (statusPage.showIncidentLabelsOnStatusPage) {
+            selectIncidents = Object.assign(Object.assign({}, selectIncidents), { labels: {
+                    name: true,
+                    color: true,
+                } });
+        }
+        if (monitorsOnStatusPage.length > 0) {
+            incidents = await IncidentService.findBy({
+                query: incidentQuery,
+                select: selectIncidents,
+                sort: {
+                    createdAt: SortOrder.Descending,
+                },
+                skip: 0,
+                limit: LIMIT_PER_PROJECT,
+                props: {
+                    isRoot: true,
+                },
+            });
+            let activeIncidents = [];
+            const unresolvedIncidentStates = await IncidentStateService.getUnresolvedIncidentStates(statusPage.projectId, {
+                isRoot: true,
+            });
+            const unresolvbedIncidentStateIds = unresolvedIncidentStates.map((state) => {
+                return state.id;
+            });
+            // If there is no particular incident id to fetch then fetch active incidents.
+            if (!incidentId) {
+                activeIncidents = await IncidentService.findBy({
+                    query: {
+                        monitors: monitorsOnStatusPage,
+                        currentIncidentStateId: QueryHelper.any(unresolvbedIncidentStateIds),
+                        projectId: statusPage.projectId,
+                    },
+                    select: selectIncidents,
+                    sort: {
+                        createdAt: SortOrder.Descending,
+                    },
+                    skip: 0,
+                    limit: LIMIT_PER_PROJECT,
+                    props: {
+                        isRoot: true,
+                    },
+                });
+            }
+            incidents = [...activeIncidents, ...incidents];
+            // get distinct by id.
+            incidents = ArrayUtil.distinctByFieldName(incidents, "_id");
+        }
+        const incidentsOnStatusPage = incidents.map((incident) => {
+            return incident.id;
+        });
+        let incidentPublicNotes = [];
+        if (incidentsOnStatusPage.length > 0) {
+            incidentPublicNotes = await IncidentPublicNoteService.findBy({
+                query: {
+                    incidentId: QueryHelper.any(incidentsOnStatusPage),
+                    projectId: statusPage.projectId,
+                },
+                select: {
+                    postedAt: true,
+                    note: true,
+                    incidentId: true,
+                },
+                sort: {
+                    postedAt: SortOrder.Descending, // new note first
+                },
+                skip: 0,
+                limit: LIMIT_PER_PROJECT,
+                props: {
+                    isRoot: true,
+                },
+            });
+        }
+        let incidentStateTimelines = [];
+        if (incidentsOnStatusPage.length > 0) {
+            incidentStateTimelines = await IncidentStateTimelineService.findBy({
+                query: {
+                    incidentId: QueryHelper.any(incidentsOnStatusPage),
+                    projectId: statusPage.projectId,
+                },
+                select: {
+                    _id: true,
+                    createdAt: true,
+                    incidentId: true,
+                    incidentState: {
+                        name: true,
+                        color: true,
+                    },
+                },
+                sort: {
+                    createdAt: SortOrder.Descending, // new note first
+                },
+                skip: 0,
+                limit: LIMIT_PER_PROJECT,
+                props: {
+                    isRoot: true,
+                },
+            });
+        }
+        // get all the incident states for this project.
+        const incidentStates = await IncidentStateService.findBy({
+            query: {
+                projectId: statusPage.projectId,
+            },
+            select: {
+                isResolvedState: true,
+                order: true,
+            },
+            limit: LIMIT_PER_PROJECT,
+            skip: 0,
+            props: {
+                isRoot: true,
+            },
+        });
+        const response = {
+            incidentPublicNotes: BaseModel.toJSONArray(incidentPublicNotes, IncidentPublicNote),
+            incidentStates: BaseModel.toJSONArray(incidentStates, IncidentState),
+            incidents: BaseModel.toJSONArray(incidents, Incident),
+            statusPageResources: BaseModel.toJSONArray(statusPageResources, StatusPageResource),
+            incidentStateTimelines: BaseModel.toJSONArray(incidentStateTimelines, IncidentStateTimeline),
+            monitorsInGroup: JSONFunctions.serialize(monitorsInGroup),
+        };
+        return response;
+    }
+}
+//# sourceMappingURL=StatusPageAPI.js.map