@oneuptime/common 7.0.3691 → 7.0.3695

package/Server/API/StatusPageAPI.ts

@@ -74,6 +74,10 @@ import StatusPageResource from "Common/Models/DatabaseModels/StatusPageResource"
 import StatusPageSSO from "Common/Models/DatabaseModels/StatusPageSso";
 import StatusPageSubscriber from "Common/Models/DatabaseModels/StatusPageSubscriber";
 import StatusPageEventType from "../../Types/StatusPage/StatusPageEventType";
+import StatusPageResourceUptimeUtil from "../../Utils/StatusPage/ResourceUptime";
+import UptimePrecision from "../../Types/StatusPage/UptimePrecision";
+import { Green } from "../../Types/BrandColors";
+import UptimeUtil from "../../Utils/Uptime/UptimeUtil";
 
 export default class StatusPageAPI extends BaseAPI<
   StatusPage,
@@ -520,17 +524,26 @@ export default class StatusPageAPI extends BaseAPI<
     this.router.post(
       `${new this.entityType()
         .getCrudApiPath()
-        ?.toString()}/overview/:statusPageId`,
+        ?.toString()}/uptime/:statusPageId`,
       UserMiddleware.getUserMiddleware,
       async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
         try {
-          const objectId: ObjectID = new ObjectID(
+          // This reosurce ID can be of a status page resource OR a status page group.
+          const statusPageResourceId: ObjectID = new ObjectID(
+            req.params["statusPageResourceId"] as string,
+          );
+
+          const statusPageId: ObjectID = new ObjectID(
             req.params["statusPageId"] as string,
           );
 
+          if (!statusPageId || !statusPageResourceId) {
+            throw new BadDataException("Status Page or Resource not found");
+          }
+
           if (
             !(await this.service.hasReadAccess(
-              objectId,
+              statusPageId,
               await CommonAPI.getDatabaseCommonInteractionProps(req),
               req,
             ))
@@ -540,231 +553,320 @@ export default class StatusPageAPI extends BaseAPI<
             );
           }
 
-          const statusPage: StatusPage | null =
-            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,
-              },
-            });
+          // get start and end date from request body.
+          // if no end date is provided then it will be current date.
+          // if no start date is provided then it will be 14 days ago from end date.
 
-          if (!statusPage) {
-            throw new BadDataException("Status Page not found");
-          }
+          let startDate: Date = OneUptimeDate.getSomeDaysAgo(14);
+          let endDate: Date = OneUptimeDate.getCurrentDate();
 
-          //get monitor statuses
+          if (req.body["startDate"]) {
+            startDate = OneUptimeDate.fromString(
+              req.body["startDate"] as string,
+            );
+          }
 
-          const monitorStatuses: Array<MonitorStatus> =
-            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,
-              },
-            });
+          if (req.body["endDate"]) {
+            endDate = OneUptimeDate.fromString(req.body["endDate"] as string);
+          }
 
-          // get resource groups.
+          if (OneUptimeDate.isAfter(startDate, endDate)) {
+            throw new BadDataException("Start date cannot be after end date");
+          }
 
-          const groups: Array<StatusPageGroup> =
-            await StatusPageGroupService.findBy({
-              query: {
-                statusPageId: objectId,
-              },
-              select: {
-                name: true,
-                order: true,
-                description: true,
-                isExpandedByDefault: true,
-                showCurrentStatus: true,
-                showUptimePercent: true,
-                uptimePercentPrecision: true,
-              },
-              sort: {
-                order: SortOrder.Ascending,
-              },
-              skip: 0,
-              limit: LIMIT_PER_PROJECT,
-              props: {
-                isRoot: true,
-              },
-            });
+          if (
+            OneUptimeDate.getDaysBetweenTwoDatesInclusive(startDate, endDate) >
+            90
+          ) {
+            throw new BadDataException(
+              "You can only get uptime for 90 days. Please select a date range within 90 days.",
+            );
+          }
 
-          // get monitors on status page.
-          const statusPageResources: Array<StatusPageResource> =
-            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 {
+            monitorStatuses,
+            monitorGroupCurrentStatuses,
+            statusPageResources,
+            statusPage,
+            monitorStatusTimelines,
+            statusPageGroups,
+            monitorsInGroup,
+          } = await this.getStatusPageResourcesAndTimelines({
+            statusPageId: statusPageId,
+            startDateForMonitorTimeline: startDate,
+            endDateForMonitorTimeline: endDate,
+          });
 
-          const monitorGroupIds: Array<ObjectID> = statusPageResources
-            .map((resource: StatusPageResource) => {
-              return resource.monitorGroupId!;
-            })
-            .filter((id: ObjectID) => {
-              return Boolean(id); // remove nulls
-            });
+          const downtimeMonitorStatuses: Array<MonitorStatus> =
+            statusPage.downtimeMonitorStatuses || [];
 
-          // get monitors in the group.
-          const monitorGroupCurrentStatuses: Dictionary<ObjectID> = {};
-          const monitorsInGroup: Dictionary<Array<ObjectID>> = {};
-
-          // get monitor status charts.
-          const monitorsOnStatusPage: Array<ObjectID> = statusPageResources
-            .map((monitor: StatusPageResource) => {
-              return monitor.monitorId!;
-            })
-            .filter((id: ObjectID) => {
-              return Boolean(id); // remove nulls
-            });
+          type ResourceUptime = {
+            statusPageResourceId: ObjectID;
+            uptimePercent: number | null;
+            statusPageResourceName: string;
+            currentStatus: MonitorStatus | null;
+          };
 
-          const monitorsOnStatusPageForTimeline: Array<ObjectID> =
-            statusPageResources
-              .filter((monitor: StatusPageResource) => {
-                return (
-                  monitor.showStatusHistoryChart || monitor.showUptimePercent
-                );
-              })
-              .map((monitor: StatusPageResource) => {
-                return monitor.monitorId!;
-              })
-              .filter((id: ObjectID) => {
-                return Boolean(id); // remove nulls
-              });
+          type StatusPageGroupUptime = {
+            statusPageGroupId: ObjectID | null;
+            uptimePercent: number | null;
+            statusPageResourceUptimes: Array<ResourceUptime>;
+            statusPageGroupName: string | null;
+            currentStatus: MonitorStatus | null;
+          };
 
-          for (const monitorGroupId of monitorGroupIds) {
-            // get current status of monitors in the group.
+          type GetUptimeByStatusPageGroup = (data: {
+            statusPageGroup: StatusPageGroup | null;
+          }) => StatusPageGroupUptime;
+
+          const getUptimeByStatusPageGroup: GetUptimeByStatusPageGroup =
+            (data: {
+              statusPageGroup: StatusPageGroup | null;
+            }): StatusPageGroupUptime => {
+              const groupUptime: StatusPageGroupUptime = {
+                statusPageGroupId:
+                  data && data.statusPageGroup
+                    ? data.statusPageGroup?.id
+                    : null,
+                uptimePercent: null,
+                statusPageResourceUptimes: [],
+                statusPageGroupName: data.statusPageGroup?.name || null,
+                currentStatus: null,
+              };
 
-            const currentStatus: MonitorStatus =
-              await MonitorGroupService.getCurrentStatus(monitorGroupId, {
-                isRoot: true,
-              });
+              const group: StatusPageGroup | null = data.statusPageGroup;
+
+              for (const resource of statusPageResources) {
+                if (
+                  (resource.statusPageGroupId &&
+                    resource.statusPageGroupId.toString() &&
+                    group &&
+                    group._id?.toString() &&
+                    group._id?.toString() ===
+                      resource.statusPageGroupId.toString()) ||
+                  (!resource.statusPageGroupId && !group)
+                ) {
+                  // if its not a monitor or a monitor group, then continue. This should ideally not happen.
+
+                  if (!resource.monitor && !resource.monitorGroupId) {
+                    continue;
+                  }
+
+                  const resourceUptime: ResourceUptime = {
+                    statusPageResourceId: resource.id!,
+                    uptimePercent: null,
+                    statusPageResourceName:
+                      resource.displayName || resource.monitor?.name || "",
+                    currentStatus: null,
+                  };
+
+                  // if its a monitor
+
+                  const precision: UptimePrecision =
+                    resource.uptimePercentPrecision ||
+                    UptimePrecision.ONE_DECIMAL;
+
+                  if (resource.monitor) {
+                    let currentStatus: MonitorStatus | undefined =
+                      monitorStatuses.find((status: MonitorStatus) => {
+                        return (
+                          status._id?.toString() ===
+                          resource.monitor?.currentMonitorStatusId?.toString()
+                        );
+                      });
+
+                    if (!currentStatus) {
+                      currentStatus = new MonitorStatus();
+                      currentStatus.name = "Operational";
+                      currentStatus.color = Green;
+
+                      resourceUptime.currentStatus = currentStatus;
+                    } else {
+                      resourceUptime.currentStatus = currentStatus;
+                    }
+
+                    if (!resource.showCurrentStatus) {
+                      resourceUptime.currentStatus = null;
+                    }
+
+                    const resourceStatusTimelines: Array<MonitorStatusTimeline> =
+                      StatusPageResourceUptimeUtil.getMonitorStatusTimelineForResource(
+                        {
+                          statusPageResource: resource,
+                          monitorStatusTimelines: monitorStatusTimelines,
+                          monitorsInGroup: monitorsInGroup,
+                        },
+                      );
+
+                    if (resource.showUptimePercent) {
+                      const uptimePercent: number =
+                        UptimeUtil.calculateUptimePercentage(
+                          resourceStatusTimelines,
+                          precision,
+                          downtimeMonitorStatuses,
+                        );
+
+                      resourceUptime.uptimePercent = uptimePercent;
+                    }
+
+                    groupUptime.statusPageResourceUptimes.push(resourceUptime);
+                  }
+
+                  // if its a monitor group, then...
+
+                  if (resource.monitorGroupId) {
+                    let currentStatus: MonitorStatus | undefined =
+                      monitorStatuses.find((status: MonitorStatus) => {
+                        return (
+                          status._id?.toString() ===
+                          monitorGroupCurrentStatuses[
+                            resource.monitorGroupId?.toString() || ""
+                          ]?.toString()
+                        );
+                      });
+
+                    if (!currentStatus) {
+                      currentStatus = new MonitorStatus();
+                      currentStatus.name = "Operational";
+                      currentStatus.color = Green;
+
+                      resourceUptime.currentStatus = currentStatus;
+                    } else {
+                      resourceUptime.currentStatus = currentStatus;
+                    }
+
+                    if (!resource.showCurrentStatus) {
+                      resourceUptime.currentStatus = null;
+                    }
+
+                    if (resource.showUptimePercent) {
+                      const resourceStatusTimelines: Array<MonitorStatusTimeline> =
+                        StatusPageResourceUptimeUtil.getMonitorStatusTimelineForResource(
+                          {
+                            statusPageResource: resource,
+                            monitorStatusTimelines: monitorStatusTimelines,
+                            monitorsInGroup: monitorsInGroup,
+                          },
+                        );
+
+                      const uptimePercent: number =
+                        UptimeUtil.calculateUptimePercentage(
+                          resourceStatusTimelines,
+                          precision,
+                          downtimeMonitorStatuses,
+                        );
+
+                      resourceUptime.uptimePercent = uptimePercent;
+                    }
+
+                    groupUptime.statusPageResourceUptimes.push(resourceUptime);
+                  }
+                }
+              }
 
-            monitorGroupCurrentStatuses[monitorGroupId.toString()] =
-              currentStatus.id!;
+              if (group?.showUptimePercent) {
+                // calculate uptime percent for the group.
+                const avgUptimePercent: number =
+                  UptimeUtil.calculateAvgUptimePercentage({
+                    uptimePercentages: groupUptime.statusPageResourceUptimes
+                      .filter((resource: ResourceUptime) => {
+                        return resource.uptimePercent !== null;
+                      })
+                      .map((resource: ResourceUptime) => {
+                        return resource.uptimePercent || 0;
+                      }),
+                    precision:
+                      group.uptimePercentPrecision ||
+                      UptimePrecision.ONE_DECIMAL,
+                  });
+
+                groupUptime.uptimePercent = avgUptimePercent;
+              }
 
-            // get monitors in the group.
+              if (group?.showCurrentStatus) {
+                const currentStatuses: Array<MonitorStatus> =
+                  groupUptime.statusPageResourceUptimes
+                    .filter((resourceUptime: ResourceUptime) => {
+                      return resourceUptime.currentStatus !== null;
+                    })
+                    .map((resourceUptime: ResourceUptime) => {
+                      return resourceUptime.currentStatus!;
+                    });
+
+                const worstStatus: MonitorStatus | null =
+                  StatusPageResourceUptimeUtil.getWorstMonitorStatus({
+                    monitorStatuses: currentStatuses,
+                  });
+
+                groupUptime.currentStatus = worstStatus;
+              }
 
-            const groupResources: Array<MonitorGroupResource> =
-              await MonitorGroupResourceService.findBy({
-                query: {
-                  monitorGroupId: monitorGroupId,
-                },
-                select: {
-                  monitorId: true,
-                },
-                props: {
-                  isRoot: true,
-                },
-                limit: LIMIT_PER_PROJECT,
-                skip: 0,
-              });
+              return groupUptime;
+            };
 
-            const monitorsInGroupIds: Array<ObjectID> = groupResources
-              .map((resource: MonitorGroupResource) => {
-                return resource.monitorId!;
-              })
-              .filter((id: ObjectID) => {
-                return Boolean(id); // remove nulls
-              });
+          const groupUptimes: Array<StatusPageGroupUptime> = [];
 
-            const shouldShowTimelineForThisGroup: boolean = Boolean(
-              statusPageResources.find((resource: StatusPageResource) => {
-                return (
-                  resource.monitorGroupId?.toString() ===
-                    monitorGroupId.toString() &&
-                  (resource.showStatusHistoryChart ||
-                    resource.showUptimePercent)
-                );
-              }),
+          for (const group of statusPageGroups) {
+            groupUptimes.push(
+              getUptimeByStatusPageGroup({ statusPageGroup: group }),
             );
+          }
 
-            for (const monitorId of monitorsInGroupIds) {
-              if (!monitorId) {
-                continue;
-              }
-
-              if (
-                !monitorsOnStatusPage.find((item: ObjectID) => {
-                  return item.toString() === monitorId.toString();
-                })
-              ) {
-                monitorsOnStatusPage.push(monitorId);
-              }
-
-              // add this to the timeline event for this group.
+          return Response.sendJsonObjectResponse(req, res, {
+            statusPageResourceUptimes: [
+              ...getUptimeByStatusPageGroup({ statusPageGroup: null })
+                .statusPageResourceUptimes,
+            ],
+            groupUptimes: groupUptimes,
+            startDate: startDate,
+            endDate: endDate,
+          });
+        } catch (err) {
+          next(err);
+        }
+      },
+    );
 
-              if (
-                shouldShowTimelineForThisGroup &&
-                !monitorsOnStatusPageForTimeline.find((item: ObjectID) => {
-                  return item.toString() === monitorId.toString();
-                })
-              ) {
-                monitorsOnStatusPageForTimeline.push(monitorId);
-              }
-            }
+    this.router.post(
+      `${new this.entityType()
+        .getCrudApiPath()
+        ?.toString()}/overview/:statusPageId`,
+      UserMiddleware.getUserMiddleware,
+      async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
+        try {
+          const objectId: ObjectID = new ObjectID(
+            req.params["statusPageId"] as string,
+          );
 
-            monitorsInGroup[monitorGroupId.toString()] = monitorsInGroupIds;
+          if (
+            !(await this.service.hasReadAccess(
+              objectId,
+              await CommonAPI.getDatabaseCommonInteractionProps(req),
+              req,
+            ))
+          ) {
+            throw new NotAuthenticatedException(
+              "You are not authenticated to access this status page",
+            );
           }
 
-          const monitorStatusTimelines: Array<MonitorStatusTimeline> =
-            await StatusPageService.getMonitorStatusTimelineForStatusPage({
-              monitorIds: monitorsOnStatusPageForTimeline,
-              historyDays: 90,
-            });
+          const startDate: Date = OneUptimeDate.getSomeDaysAgo(90);
+          const endDate: Date = OneUptimeDate.getCurrentDate();
+
+          const {
+            monitorStatuses,
+            monitorGroupCurrentStatuses,
+            statusPageResources,
+            statusPage,
+            monitorsOnStatusPage,
+            monitorStatusTimelines,
+            statusPageGroups,
+            monitorsInGroup,
+          } = await this.getStatusPageResourcesAndTimelines({
+            statusPageId: objectId,
+            startDateForMonitorTimeline: startDate,
+            endDateForMonitorTimeline: endDate,
+          });
 
           // check if status page has active incident.
           let activeIncidents: Array<Incident> = [];
@@ -1135,7 +1237,10 @@ export default class StatusPageAPI extends BaseAPI<
               monitorStatusTimelines,
               MonitorStatusTimeline,
             ),
-            resourceGroups: BaseModel.toJSONArray(groups, StatusPageGroup),
+            resourceGroups: BaseModel.toJSONArray(
+              statusPageGroups,
+              StatusPageGroup,
+            ),
             monitorStatuses: BaseModel.toJSONArray(
               monitorStatuses,
               MonitorStatus,
@@ -2352,4 +2457,254 @@ export default class StatusPageAPI extends BaseAPI<
 
     return currentStatus;
   }
+
+  public async getStatusPageResourcesAndTimelines(data: {
+    statusPageId: ObjectID;
+    startDateForMonitorTimeline: Date;
+    endDateForMonitorTimeline: Date;
+  }): Promise<{
+    statusPageResources: StatusPageResource[];
+    monitorStatuses: MonitorStatus[];
+    monitorStatusTimelines: MonitorStatusTimeline[];
+    monitorGroupCurrentStatuses: Dictionary<ObjectID>;
+    statusPageGroups: StatusPageGroup[];
+    statusPage: StatusPage;
+    monitorsOnStatusPage: ObjectID[];
+    monitorsInGroup: Dictionary<ObjectID[]>;
+  }> {
+    const objectId: ObjectID = data.statusPageId;
+
+    const statusPage: StatusPage | null = 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: Array<MonitorStatus> =
+      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: Array<StatusPageGroup> = await StatusPageGroupService.findBy({
+      query: {
+        statusPageId: objectId,
+      },
+      select: {
+        name: true,
+        order: true,
+        description: true,
+        isExpandedByDefault: true,
+        showCurrentStatus: true,
+        showUptimePercent: true,
+        uptimePercentPrecision: true,
+      },
+      sort: {
+        order: SortOrder.Ascending,
+      },
+      skip: 0,
+      limit: LIMIT_PER_PROJECT,
+      props: {
+        isRoot: true,
+      },
+    });
+
+    // get monitors on status page.
+    const statusPageResources: Array<StatusPageResource> =
+      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: Array<ObjectID> = statusPageResources
+      .map((resource: StatusPageResource) => {
+        return resource.monitorGroupId!;
+      })
+      .filter((id: ObjectID) => {
+        return Boolean(id); // remove nulls
+      });
+
+    // get monitors in the group.
+    const monitorGroupCurrentStatuses: Dictionary<ObjectID> = {};
+    const monitorsInGroup: Dictionary<Array<ObjectID>> = {};
+
+    // get monitor status charts.
+    const monitorsOnStatusPage: Array<ObjectID> = statusPageResources
+      .map((monitor: StatusPageResource) => {
+        return monitor.monitorId!;
+      })
+      .filter((id: ObjectID) => {
+        return Boolean(id); // remove nulls
+      });
+
+    const monitorsOnStatusPageForTimeline: Array<ObjectID> = statusPageResources
+      .filter((monitor: StatusPageResource) => {
+        return monitor.showStatusHistoryChart || monitor.showUptimePercent;
+      })
+      .map((monitor: StatusPageResource) => {
+        return monitor.monitorId!;
+      })
+      .filter((id: ObjectID) => {
+        return Boolean(id); // remove nulls
+      });
+
+    for (const monitorGroupId of monitorGroupIds) {
+      // get current status of monitors in the group.
+
+      const currentStatus: MonitorStatus =
+        await MonitorGroupService.getCurrentStatus(monitorGroupId, {
+          isRoot: true,
+        });
+
+      monitorGroupCurrentStatuses[monitorGroupId.toString()] =
+        currentStatus.id!;
+
+      // get monitors in the group.
+
+      const groupResources: Array<MonitorGroupResource> =
+        await MonitorGroupResourceService.findBy({
+          query: {
+            monitorGroupId: monitorGroupId,
+          },
+          select: {
+            monitorId: true,
+          },
+          props: {
+            isRoot: true,
+          },
+          limit: LIMIT_PER_PROJECT,
+          skip: 0,
+        });
+
+      const monitorsInGroupIds: Array<ObjectID> = groupResources
+        .map((resource: MonitorGroupResource) => {
+          return resource.monitorId!;
+        })
+        .filter((id: ObjectID) => {
+          return Boolean(id); // remove nulls
+        });
+
+      const shouldShowTimelineForThisGroup: boolean = Boolean(
+        statusPageResources.find((resource: StatusPageResource) => {
+          return (
+            resource.monitorGroupId?.toString() === monitorGroupId.toString() &&
+            (resource.showStatusHistoryChart || resource.showUptimePercent)
+          );
+        }),
+      );
+
+      for (const monitorId of monitorsInGroupIds) {
+        if (!monitorId) {
+          continue;
+        }
+
+        if (
+          !monitorsOnStatusPage.find((item: ObjectID) => {
+            return item.toString() === monitorId.toString();
+          })
+        ) {
+          monitorsOnStatusPage.push(monitorId);
+        }
+
+        // add this to the timeline event for this group.
+
+        if (
+          shouldShowTimelineForThisGroup &&
+          !monitorsOnStatusPageForTimeline.find((item: ObjectID) => {
+            return item.toString() === monitorId.toString();
+          })
+        ) {
+          monitorsOnStatusPageForTimeline.push(monitorId);
+        }
+      }
+
+      monitorsInGroup[monitorGroupId.toString()] = monitorsInGroupIds;
+    }
+
+    const monitorStatusTimelines: Array<MonitorStatusTimeline> =
+      await StatusPageService.getMonitorStatusTimelineForStatusPage({
+        monitorIds: monitorsOnStatusPageForTimeline,
+        startDate: data.startDateForMonitorTimeline,
+        endDate: data.endDateForMonitorTimeline,
+      });
+
+    // return everything.
+
+    return {
+      statusPageResources,
+      monitorStatuses,
+      monitorGroupCurrentStatuses,
+      statusPageGroups: groups,
+      monitorStatusTimelines,
+      statusPage,
+      monitorsOnStatusPage,
+      monitorsInGroup,
+    };
+  }
 }