@oneuptime/common 10.0.39 → 10.0.41

package/Server/API/DashboardAPI.ts

@@ -0,0 +1,408 @@
+import UserMiddleware from "../Middleware/UserAuthorization";
+import DashboardService, {
+  Service as DashboardServiceType,
+} from "../Services/DashboardService";
+import DashboardDomainService from "../Services/DashboardDomainService";
+import CookieUtil from "../Utils/Cookie";
+import logger from "../Utils/Logger";
+import {
+  ExpressRequest,
+  ExpressResponse,
+  NextFunction,
+} from "../Utils/Express";
+import Response from "../Utils/Response";
+import BaseAPI from "./BaseAPI";
+import BadDataException from "../../Types/Exception/BadDataException";
+import NotFoundException from "../../Types/Exception/NotFoundException";
+import HashedString from "../../Types/HashedString";
+import ObjectID from "../../Types/ObjectID";
+import Dashboard from "../../Models/DatabaseModels/Dashboard";
+import DashboardDomain from "../../Models/DatabaseModels/DashboardDomain";
+import { EncryptionSecret } from "../EnvironmentConfig";
+import { DASHBOARD_MASTER_PASSWORD_INVALID_MESSAGE } from "../../Types/Dashboard/MasterPassword";
+import NotAuthenticatedException from "../../Types/Exception/NotAuthenticatedException";
+import ForbiddenException from "../../Types/Exception/ForbiddenException";
+import JSONFunctions from "../../Types/JSONFunctions";
+
+export default class DashboardAPI extends BaseAPI<
+  Dashboard,
+  DashboardServiceType
+> {
+  public constructor() {
+    super(Dashboard, DashboardService);
+
+    // SEO endpoint - resolve dashboard by ID or domain
+    this.router.get(
+      `${new this.entityType()
+        .getCrudApiPath()
+        ?.toString()}/seo/:dashboardIdOrDomain`,
+      UserMiddleware.getUserMiddleware,
+      async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
+        try {
+          const dashboardIdOrDomain: string = req.params[
+            "dashboardIdOrDomain"
+          ] as string;
+
+          let dashboardId: ObjectID | null = null;
+
+          if (dashboardIdOrDomain && dashboardIdOrDomain.includes(".")) {
+            // This is a domain - resolve to dashboard ID
+            const dashboardDomain: DashboardDomain | null =
+              await DashboardDomainService.findOneBy({
+                query: {
+                  fullDomain: dashboardIdOrDomain,
+                  domain: {
+                    isVerified: true,
+                  } as any,
+                },
+                select: {
+                  dashboardId: true,
+                },
+                props: {
+                  isRoot: true,
+                },
+              });
+
+            if (!dashboardDomain || !dashboardDomain.dashboardId) {
+              return Response.sendErrorResponse(
+                req,
+                res,
+                new NotFoundException("Dashboard not found"),
+              );
+            }
+
+            dashboardId = dashboardDomain.dashboardId;
+          } else {
+            try {
+              dashboardId = new ObjectID(dashboardIdOrDomain);
+            } catch (err) {
+              logger.error(err);
+              return Response.sendErrorResponse(
+                req,
+                res,
+                new BadDataException("Invalid dashboard ID"),
+              );
+            }
+          }
+
+          const dashboard: Dashboard | null =
+            await DashboardService.findOneById({
+              id: dashboardId,
+              select: {
+                _id: true,
+                name: true,
+                description: true,
+                pageTitle: true,
+                pageDescription: true,
+              },
+              props: {
+                isRoot: true,
+              },
+            });
+
+          if (!dashboard) {
+            return Response.sendErrorResponse(
+              req,
+              res,
+              new NotFoundException("Dashboard not found"),
+            );
+          }
+
+          return Response.sendJsonObjectResponse(req, res, {
+            _id: dashboard._id?.toString() || "",
+            title: dashboard.pageTitle || dashboard.name || "Dashboard",
+            description:
+              dashboard.pageDescription ||
+              dashboard.description ||
+              "View dashboard metrics and insights.",
+          });
+        } catch (err) {
+          next(err);
+        }
+      },
+    );
+
+    // Domain resolution endpoint
+    this.router.post(
+      `${new this.entityType().getCrudApiPath()?.toString()}/domain`,
+      UserMiddleware.getUserMiddleware,
+      async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
+        try {
+          if (!req.body["domain"]) {
+            throw new BadDataException("domain is required in request body");
+          }
+
+          const domain: string = req.body["domain"] as string;
+
+          const dashboardDomain: DashboardDomain | null =
+            await DashboardDomainService.findOneBy({
+              query: {
+                fullDomain: domain,
+                domain: {
+                  isVerified: true,
+                } as any,
+              },
+              select: {
+                dashboardId: true,
+              },
+              props: {
+                isRoot: true,
+              },
+            });
+
+          if (!dashboardDomain) {
+            throw new BadDataException("No dashboard found with this domain");
+          }
+
+          const objectId: ObjectID = dashboardDomain.dashboardId!;
+
+          return Response.sendJsonObjectResponse(req, res, {
+            dashboardId: objectId.toString(),
+          });
+        } catch (err) {
+          next(err);
+        }
+      },
+    );
+
+    // Metadata endpoint - returns dashboard info for the public viewer
+    this.router.post(
+      `${new this.entityType()
+        .getCrudApiPath()
+        ?.toString()}/metadata/:dashboardId`,
+      UserMiddleware.getUserMiddleware,
+      async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
+        try {
+          const dashboardId: ObjectID = new ObjectID(
+            req.params["dashboardId"] as string,
+          );
+
+          const dashboard: Dashboard | null =
+            await DashboardService.findOneById({
+              id: dashboardId,
+              select: {
+                _id: true,
+                name: true,
+                description: true,
+                isPublicDashboard: true,
+                enableMasterPassword: true,
+                pageTitle: true,
+                pageDescription: true,
+                logoFile: {
+                  file: true,
+                  fileType: true,
+                },
+                faviconFile: {
+                  file: true,
+                  fileType: true,
+                },
+              },
+              props: {
+                isRoot: true,
+              },
+            });
+
+          if (!dashboard) {
+            throw new NotFoundException("Dashboard not found");
+          }
+
+          return Response.sendJsonObjectResponse(req, res, {
+            _id: dashboard._id?.toString() || "",
+            name: dashboard.name || "Dashboard",
+            description: dashboard.description || "",
+            isPublicDashboard: dashboard.isPublicDashboard || false,
+            enableMasterPassword: dashboard.enableMasterPassword || false,
+            pageTitle: dashboard.pageTitle || "",
+            pageDescription: dashboard.pageDescription || "",
+            logoFile: DashboardAPI.getFileAsBase64JSONObject(
+              dashboard.logoFile,
+            ),
+            faviconFile: DashboardAPI.getFileAsBase64JSONObject(
+              dashboard.faviconFile,
+            ),
+          });
+        } catch (err) {
+          next(err);
+        }
+      },
+    );
+
+    // Public view-config endpoint - returns dashboard view config for the public viewer
+    this.router.post(
+      `${new this.entityType()
+        .getCrudApiPath()
+        ?.toString()}/view-config/:dashboardId`,
+      UserMiddleware.getUserMiddleware,
+      async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
+        try {
+          const dashboardId: ObjectID = new ObjectID(
+            req.params["dashboardId"] as string,
+          );
+
+          // Check read access (handles public check, IP whitelist, master password)
+          const accessResult: {
+            hasReadAccess: boolean;
+            error?: NotAuthenticatedException | ForbiddenException;
+          } = await DashboardService.hasReadAccess({
+            dashboardId,
+            req,
+          });
+
+          if (!accessResult.hasReadAccess) {
+            throw (
+              accessResult.error ||
+              new BadDataException("Access denied to this dashboard.")
+            );
+          }
+
+          const dashboard: Dashboard | null =
+            await DashboardService.findOneById({
+              id: dashboardId,
+              select: {
+                _id: true,
+                name: true,
+                description: true,
+                dashboardViewConfig: true,
+                pageTitle: true,
+                pageDescription: true,
+                logoFile: {
+                  file: true,
+                  fileType: true,
+                },
+              },
+              props: {
+                isRoot: true,
+              },
+            });
+
+          if (!dashboard) {
+            throw new NotFoundException("Dashboard not found");
+          }
+
+          return Response.sendJsonObjectResponse(req, res, {
+            _id: dashboard._id?.toString() || "",
+            name: dashboard.name || "Dashboard",
+            description: dashboard.description || "",
+            pageTitle: dashboard.pageTitle || "",
+            pageDescription: dashboard.pageDescription || "",
+            logoFile: DashboardAPI.getFileAsBase64JSONObject(
+              dashboard.logoFile,
+            ),
+            dashboardViewConfig: dashboard.dashboardViewConfig
+              ? JSONFunctions.serialize(dashboard.dashboardViewConfig as any)
+              : null,
+          });
+        } catch (err) {
+          next(err);
+        }
+      },
+    );
+
+    this.router.post(
+      `${new this.entityType()
+        .getCrudApiPath()
+        ?.toString()}/master-password/:dashboardId`,
+      UserMiddleware.getUserMiddleware,
+      async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
+        try {
+          if (!req.params["dashboardId"]) {
+            throw new BadDataException("Dashboard ID not found");
+          }
+
+          const dashboardId: ObjectID = new ObjectID(
+            req.params["dashboardId"] as string,
+          );
+
+          const password: string | undefined =
+            req.body && (req.body["password"] as string);
+
+          if (!password) {
+            throw new BadDataException("Master password is required.");
+          }
+
+          const dashboard: Dashboard | null =
+            await DashboardService.findOneById({
+              id: dashboardId,
+              select: {
+                _id: true,
+                projectId: true,
+                enableMasterPassword: true,
+                masterPassword: true,
+                isPublicDashboard: true,
+              },
+              props: {
+                isRoot: true,
+              },
+            });
+
+          if (!dashboard) {
+            throw new NotFoundException("Dashboard not found");
+          }
+
+          if (!dashboard.isPublicDashboard) {
+            throw new BadDataException(
+              "This dashboard is not publicly accessible.",
+            );
+          }
+
+          if (!dashboard.enableMasterPassword || !dashboard.masterPassword) {
+            throw new BadDataException(
+              "Master password has not been configured for this dashboard.",
+            );
+          }
+
+          const hashedInput: string = await HashedString.hashValue(
+            password,
+            EncryptionSecret,
+          );
+
+          if (hashedInput !== dashboard.masterPassword.toString()) {
+            throw new BadDataException(
+              DASHBOARD_MASTER_PASSWORD_INVALID_MESSAGE,
+            );
+          }
+
+          CookieUtil.setDashboardMasterPasswordCookie({
+            expressResponse: res,
+            dashboardId,
+          });
+
+          return Response.sendEmptySuccessResponse(req, res);
+        } catch (err) {
+          next(err);
+        }
+      },
+    );
+  }
+
+  private static getFileAsBase64JSONObject(
+    file: any,
+  ): { file: string; fileType: string } | null {
+    if (!file || !file.file) {
+      return null;
+    }
+
+    let base64: string;
+    const fileBuffer: any = file.file;
+
+    if (Buffer.isBuffer(fileBuffer)) {
+      base64 = fileBuffer.toString("base64");
+    } else if (
+      fileBuffer &&
+      typeof fileBuffer === "object" &&
+      fileBuffer.value &&
+      fileBuffer.value.data
+    ) {
+      base64 = Buffer.from(fileBuffer.value.data).toString("base64");
+    } else if (typeof fileBuffer === "string") {
+      base64 = fileBuffer;
+    } else {
+      return null;
+    }
+
+    return {
+      file: base64,
+      fileType: (file.fileType as string) || "image/png",
+    };
+  }
+}

package/Server/API/DashboardDomainAPI.ts

@@ -0,0 +1,235 @@
+import { DashboardCNameRecord } from "../EnvironmentConfig";
+import UserMiddleware from "../Middleware/UserAuthorization";
+import DashboardDomainService, {
+  Service as DashboardDomainServiceType,
+} from "../Services/DashboardDomainService";
+import {
+  ExpressRequest,
+  ExpressResponse,
+  NextFunction,
+} from "../Utils/Express";
+import logger from "../Utils/Logger";
+import Response from "../Utils/Response";
+import BaseAPI from "./BaseAPI";
+import CommonAPI from "./CommonAPI";
+import DatabaseCommonInteractionProps from "../../Types/BaseDatabase/DatabaseCommonInteractionProps";
+import BadDataException from "../../Types/Exception/BadDataException";
+import ObjectID from "../../Types/ObjectID";
+import PositiveNumber from "../../Types/PositiveNumber";
+import DashboardDomain from "../../Models/DatabaseModels/DashboardDomain";
+
+export default class DashboardDomainAPI extends BaseAPI<
+  DashboardDomain,
+  DashboardDomainServiceType
+> {
+  public constructor() {
+    super(DashboardDomain, DashboardDomainService);
+
+    // CNAME verification api
+    this.router.get(
+      `${new this.entityType().getCrudApiPath()?.toString()}/verify-cname/:id`,
+      UserMiddleware.getUserMiddleware,
+      async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
+        try {
+          if (!DashboardCNameRecord) {
+            return Response.sendErrorResponse(
+              req,
+              res,
+              new BadDataException(
+                `Custom Domains not enabled for this
+                                OneUptime installation. Please contact
+                                your server admin to enable this
+                                feature.`,
+              ),
+            );
+          }
+
+          const databaseProps: DatabaseCommonInteractionProps =
+            await CommonAPI.getDatabaseCommonInteractionProps(req);
+
+          const id: ObjectID = new ObjectID(req.params["id"] as string);
+
+          const domainCount: PositiveNumber =
+            await DashboardDomainService.countBy({
+              query: {
+                _id: id.toString(),
+              },
+              props: databaseProps,
+            });
+
+          if (domainCount.toNumber() === 0) {
+            return Response.sendErrorResponse(
+              req,
+              res,
+              new BadDataException(
+                "The domain does not exist or user does not have access to it.",
+              ),
+            );
+          }
+
+          const domain: DashboardDomain | null =
+            await DashboardDomainService.findOneBy({
+              query: {
+                _id: id.toString(),
+              },
+              select: {
+                _id: true,
+                fullDomain: true,
+              },
+              props: {
+                isRoot: true,
+              },
+            });
+
+          if (!domain) {
+            return Response.sendErrorResponse(
+              req,
+              res,
+              new BadDataException("Invalid token."),
+            );
+          }
+
+          if (!domain.fullDomain) {
+            return Response.sendErrorResponse(
+              req,
+              res,
+              new BadDataException("Invalid domain."),
+            );
+          }
+
+          const isValid: boolean = await DashboardDomainService.isCnameValid(
+            domain.fullDomain!,
+          );
+
+          if (!isValid) {
+            return Response.sendErrorResponse(
+              req,
+              res,
+              new BadDataException(
+                "CNAME is not verified. Please make sure you have the correct record and please verify CNAME again. If you are sure that the record is correct, please wait for some time for the DNS to propagate.",
+              ),
+            );
+          }
+
+          return Response.sendEmptySuccessResponse(req, res);
+        } catch (e) {
+          next(e);
+        }
+      },
+    );
+
+    // Provision SSL API
+    this.router.get(
+      `${new this.entityType().getCrudApiPath()?.toString()}/order-ssl/:id`,
+      UserMiddleware.getUserMiddleware,
+      async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
+        try {
+          if (!DashboardCNameRecord) {
+            return Response.sendErrorResponse(
+              req,
+              res,
+              new BadDataException(
+                `Custom Domains not enabled for this
+                                OneUptime installation. Please contact
+                                your server admin to enable this
+                                feature.`,
+              ),
+            );
+          }
+
+          const databaseProps: DatabaseCommonInteractionProps =
+            await CommonAPI.getDatabaseCommonInteractionProps(req);
+
+          const id: ObjectID = new ObjectID(req.params["id"] as string);
+
+          const domainCount: PositiveNumber =
+            await DashboardDomainService.countBy({
+              query: {
+                _id: id.toString(),
+              },
+              props: databaseProps,
+            });
+
+          if (domainCount.toNumber() === 0) {
+            return Response.sendErrorResponse(
+              req,
+              res,
+              new BadDataException(
+                "The domain does not exist or user does not have access to it.",
+              ),
+            );
+          }
+
+          const domain: DashboardDomain | null =
+            await DashboardDomainService.findOneBy({
+              query: {
+                _id: id.toString(),
+              },
+              select: {
+                _id: true,
+                fullDomain: true,
+                cnameVerificationToken: true,
+                isCnameVerified: true,
+                isSslProvisioned: true,
+              },
+              props: {
+                isRoot: true,
+              },
+            });
+
+          if (!domain) {
+            return Response.sendErrorResponse(
+              req,
+              res,
+              new BadDataException("Invalid token."),
+            );
+          }
+
+          if (!domain.cnameVerificationToken) {
+            return Response.sendErrorResponse(
+              req,
+              res,
+              new BadDataException("Invalid token."),
+            );
+          }
+
+          if (!domain.isCnameVerified) {
+            return Response.sendErrorResponse(
+              req,
+              res,
+              new BadDataException(
+                "CNAME is not verified. Please verify CNAME first before you provision SSL.",
+              ),
+            );
+          }
+
+          if (domain.isSslProvisioned) {
+            return Response.sendErrorResponse(
+              req,
+              res,
+              new BadDataException("SSL is already provisioned."),
+            );
+          }
+
+          if (!domain.fullDomain) {
+            return Response.sendErrorResponse(
+              req,
+              res,
+              new BadDataException("Invalid domain."),
+            );
+          }
+
+          logger.debug("Ordering SSL");
+
+          await DashboardDomainService.orderCert(domain);
+
+          logger.debug("SSL Provisioned for domain - " + domain.fullDomain);
+
+          return Response.sendEmptySuccessResponse(req, res);
+        } catch (e) {
+          next(e);
+        }
+      },
+    );
+  }
+}

package/Server/API/StatusPageAPI.ts

@@ -1443,7 +1443,33 @@ export default class StatusPageAPI extends BaseAPI<
             req: req,
           });
 
-          const startDate: Date = OneUptimeDate.getSomeDaysAgo(90);
+          // First fetch the status page to get the configured uptime history days
+          const statusPageForDays: StatusPage | null =
+            await StatusPageService.findOneBy({
+              query: {
+                _id: statusPageId.toString(),
+              },
+              select: {
+                showUptimeHistoryInDays: true,
+              },
+              props: {
+                isRoot: true,
+              },
+            });
+
+          let uptimeHistoryDays: number =
+            statusPageForDays?.showUptimeHistoryInDays || 90;
+
+          if (uptimeHistoryDays > 90) {
+            uptimeHistoryDays = 90;
+          }
+
+          if (uptimeHistoryDays < 1) {
+            uptimeHistoryDays = 1;
+          }
+
+          const startDate: Date =
+            OneUptimeDate.getSomeDaysAgo(uptimeHistoryDays);
           const endDate: Date = OneUptimeDate.getCurrentDate();
 
           const {
@@ -2208,7 +2234,14 @@ export default class StatusPageAPI extends BaseAPI<
               incidentStateTimelines,
               IncidentStateTimeline,
             ),
-            statusPage: BaseModel.toJSONObject(statusPage, StatusPage),
+            statusPage: (() => {
+              const statusPageJson: JSONObject = BaseModel.toJSONObject(
+                statusPage,
+                StatusPage,
+              );
+              delete statusPageJson["projectId"];
+              return statusPageJson;
+            })(),
             scheduledMaintenanceStateTimelines: BaseModel.toJSONArray(
               scheduledMaintenanceStateTimelines,
               ScheduledMaintenanceStateTimeline,
@@ -4448,6 +4481,7 @@ export default class StatusPageAPI extends BaseAPI<
         showIncidentsOnStatusPage: true,
         showEpisodesOnStatusPage: true,
         showScheduledMaintenanceEventsOnStatusPage: true,
+        showUptimeHistoryInDays: true,
       },
       props: {
         isRoot: true,