@oneuptime/common 7.0.3156 → 7.0.3162

package/Models/DatabaseModels/StatusPageDomain.ts

@@ -538,4 +538,90 @@ export default class StatusPageDomain extends BaseModel {
     transformer: ObjectID.getDatabaseTransformer(),
   })
   public deletedByUserId?: ObjectID = undefined;
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.CreateStatusPageDomain,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadStatusPageDomain,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.EditStatusPageDomain,
+    ],
+  })
+  @TableColumn({ type: TableColumnType.VeryLongText })
+  @Column({
+    type: ColumnType.VeryLongText,
+    nullable: true,
+    unique: false,
+  })
+  public customCertificate?: string = undefined;
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.CreateStatusPageDomain,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadStatusPageDomain,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.EditStatusPageDomain,
+    ],
+  })
+  @TableColumn({ type: TableColumnType.VeryLongText })
+  @Column({
+    type: ColumnType.VeryLongText,
+    nullable: true,
+    unique: false,
+  })
+  public customCertificateKey?: string = undefined;
+
+  // If this is true, then the certificate is custom and not managed by OneUptime (LetsEncrypt)
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.CreateStatusPageDomain,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadStatusPageDomain,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.EditStatusPageDomain,
+    ],
+  })
+  @TableColumn({ type: TableColumnType.Boolean })
+  @Column({
+    type: ColumnType.Boolean,
+    nullable: false,
+    unique: false,
+    default: false, // default is false
+  })
+  public isCustomCertificate?: boolean = undefined;
 }

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

@@ -0,0 +1,29 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class MigrationName1728472625805 implements MigrationInterface {
+  public name = "MigrationName1728472625805";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "StatusPageDomain" ADD "customCertificate" text`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "StatusPageDomain" ADD "customCertificateKey" text`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "StatusPageDomain" ADD "isCustomCertificate" boolean NOT NULL DEFAULT false`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "StatusPageDomain" DROP COLUMN "isCustomCertificate"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "StatusPageDomain" DROP COLUMN "customCertificateKey"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "StatusPageDomain" DROP COLUMN "customCertificate"`,
+    );
+  }
+}

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

@@ -73,6 +73,7 @@ import { MigrationName1727194211048 } from "./1727194211048-MigrationName";
 import { MigrationName1727194579925 } from "./1727194579925-MigrationName";
 import { MigrationName1727894983857 } from "./1727894983857-MigrationName";
 import { MigrationName1727906598804 } from "./1727906598804-MigrationName";
+import { MigrationName1728472625805 } from "./1728472625805-MigrationName";
 
 export default [
   InitialMigration,
@@ -150,4 +151,5 @@ export default [
   MigrationName1727194579925,
   MigrationName1727894983857,
   MigrationName1727906598804,
+  MigrationName1728472625805,
 ];

package/Server/Services/StatusPageDomainService.ts

@@ -50,6 +50,17 @@ export class Service extends DatabaseService<StatusPageDomain> {
 
     createBy.data.cnameVerificationToken = ObjectID.generate().toString();
 
+    if (createBy.data.isCustomCertificate) {
+      if (
+        !createBy.data.customCertificate ||
+        !createBy.data.customCertificateKey
+      ) {
+        throw new BadDataException(
+          "Custom certificate or private key is missing",
+        );
+      }
+    }
+
     return { createBy, carryForward: null };
   }
 
@@ -168,6 +179,7 @@ export class Service extends DatabaseService<StatusPageDomain> {
     const domains: Array<StatusPageDomain> = await this.findBy({
       query: {
         isSslOrdered: true,
+        isCustomCertificate: false,
       },
       select: {
         _id: true,
@@ -419,6 +431,7 @@ export class Service extends DatabaseService<StatusPageDomain> {
           const domains: Array<StatusPageDomain> = await this.findBy({
             query: {
               isSslOrdered: false,
+              isCustomCertificate: false, // only order for non custom certificates.
             },
             select: {
               _id: true,
@@ -507,6 +520,7 @@ export class Service extends DatabaseService<StatusPageDomain> {
     const domains: Array<StatusPageDomain> = await this.findBy({
       query: {
         isSslOrdered: true,
+        isCustomCertificate: false,
       },
       select: {
         _id: true,

package/Types/WebsiteRequest.ts

@@ -21,6 +21,7 @@ export default class WebsiteRequest {
       headers?: Headers | undefined;
       timeout?: number | undefined;
       isHeadRequest?: boolean | undefined;
+      doNotFollowRedirects?: boolean | undefined;
     },
   ): Promise<WebsiteResponse> {
     const axiosOptions: AxiosRequestConfig = {
@@ -36,6 +37,10 @@ export default class WebsiteRequest {
       axiosOptions.method = HTTPMethod.HEAD;
     }
 
+    if (options.doNotFollowRedirects) {
+      axiosOptions.maxRedirects = 0;
+    }
+
     // use axios to fetch an HTML page
     let response: AxiosResponse | null = null;
 

package/Utils/API.ts

@@ -18,6 +18,7 @@ export interface RequestOptions {
   retries?: number | undefined;
   exponentialBackoff?: boolean | undefined;
   timeout?: number | undefined;
+  doNotFollowRedirects?: boolean | undefined;
 }
 
 export default class API {
@@ -395,6 +396,10 @@ export default class API {
             axiosOptions.timeout = options.timeout;
           }
 
+          if (options?.doNotFollowRedirects) {
+            axiosOptions.maxRedirects = 0;
+          }
+
           result = await axios(axiosOptions);
 
           break;

package/Utils/StatusPage/ResourceUptime.ts

@@ -0,0 +1,301 @@
+import { Green } from "../../Types/BrandColors";
+import ObjectID from "../../Types/ObjectID";
+import MonitorStatus from "../../Models/DatabaseModels/MonitorStatus";
+import MonitorStatusTimeline from "../../Models/DatabaseModels/MonitorStatusTimeline";
+import StatusPageResource from "../../Models/DatabaseModels/StatusPageResource";
+import Dictionary from "../../Types/Dictionary";
+import UptimePrecision from "../../Types/StatusPage/UptimePrecision";
+import StatusPageGroup from "../../Models/DatabaseModels/StatusPageGroup";
+import UptimeUtil from "../Uptime/UptimeUtil";
+
+export default class StatusPageResourceUptimeUtil {
+  public static getMonitorStatusTimelineForResource(data: {
+    statusPageResource: StatusPageResource;
+    monitorStatusTimelines: Array<MonitorStatusTimeline>;
+    monitorsInGroup: Dictionary<Array<ObjectID>>;
+  }): Array<MonitorStatusTimeline> {
+    return [...data.monitorStatusTimelines].filter(
+      (timeline: MonitorStatusTimeline) => {
+        // check monitor if first.
+
+        if (data.statusPageResource.monitorId) {
+          return (
+            timeline.monitorId?.toString() ===
+            data.statusPageResource.monitorId?.toString()
+          );
+        }
+
+        if (data.statusPageResource.monitorGroupId) {
+          const monitorsInThisGroup: Array<ObjectID> | undefined =
+            data.monitorsInGroup[
+              data.statusPageResource.monitorGroupId?.toString() || ""
+            ];
+
+          if (!monitorsInThisGroup) {
+            return false;
+          }
+
+          return monitorsInThisGroup.find((monitorId: ObjectID) => {
+            return monitorId.toString() === timeline.monitorId?.toString();
+          });
+        }
+
+        return false;
+      },
+    );
+  }
+
+  public static getCurrentStatusPageGroupStatus(data: {
+    statusPageGroup: StatusPageGroup;
+    monitorStatusTimelines: Array<MonitorStatusTimeline>;
+    statusPageResources: Array<StatusPageResource>;
+    monitorStatuses: Array<MonitorStatus>;
+    monitorGroupCurrentStatuses: Dictionary<ObjectID>;
+  }): MonitorStatus {
+    let currentStatus: MonitorStatus = new MonitorStatus();
+    currentStatus.name = "Operational";
+    currentStatus.color = Green;
+
+    const resourcesInGroup: Array<StatusPageResource> =
+      this.getResourcesInStatusPageGroup({
+        statusPageGroup: data.statusPageGroup,
+        statusPageResources: data.statusPageResources,
+      });
+
+    for (const resource of resourcesInGroup) {
+      let currentMonitorStatus: MonitorStatus | undefined = undefined;
+
+      if (resource.monitor) {
+        currentMonitorStatus = data.monitorStatuses.find(
+          (status: MonitorStatus) => {
+            return (
+              status._id?.toString() ===
+              resource.monitor?.currentMonitorStatusId?.toString()
+            );
+          },
+        );
+      }
+
+      if (resource.monitorGroupId) {
+        currentMonitorStatus = data.monitorStatuses.find(
+          (status: MonitorStatus) => {
+            return (
+              status._id?.toString() ===
+              data.monitorGroupCurrentStatuses[
+                resource.monitorGroupId?.toString() || ""
+              ]?.toString()
+            );
+          },
+        );
+      }
+
+      if (!currentMonitorStatus) {
+        currentMonitorStatus = currentStatus;
+      }
+
+      if (
+        (currentStatus &&
+          currentStatus.priority &&
+          currentMonitorStatus?.priority &&
+          currentMonitorStatus?.priority > currentStatus.priority) ||
+        !currentStatus ||
+        !currentStatus.priority
+      ) {
+        currentStatus = currentMonitorStatus!;
+      }
+    }
+
+    return currentStatus;
+  }
+
+  public static calculateUptimePercentOfResource(data: {
+    statusPageResource: StatusPageResource;
+    monitorStatusTimelines: Array<MonitorStatusTimeline>;
+    precision: UptimePrecision;
+    downtimeMonitorStatuses: Array<MonitorStatus>;
+    monitorsInGroup: Dictionary<Array<ObjectID>>;
+  }): number | null {
+    if (!data.statusPageResource.showUptimePercent) {
+      return null;
+    }
+
+    const monitorStatusTimelines: Array<MonitorStatusTimeline> =
+      this.getMonitorStatusTimelineForResource({
+        statusPageResource: data.statusPageResource,
+        monitorStatusTimelines: data.monitorStatusTimelines,
+        monitorsInGroup: data.monitorsInGroup,
+      });
+
+    const downtimeMonitorStatuses: Array<MonitorStatus> =
+      data?.downtimeMonitorStatuses || [];
+
+    const uptimePercent: number = UptimeUtil.calculateUptimePercentage(
+      monitorStatusTimelines,
+      data.precision,
+      downtimeMonitorStatuses,
+    );
+
+    return uptimePercent;
+  }
+
+  public static calculateAvgUptimePercentOfStatusPageGroup(data: {
+    statusPageGroup: StatusPageGroup;
+    monitorStatusTimelines: Array<MonitorStatusTimeline>;
+    precision: UptimePrecision;
+    downtimeMonitorStatuses: Array<MonitorStatus>;
+    statusPageResources: Array<StatusPageResource>;
+    monitorsInGroup: Dictionary<Array<ObjectID>>;
+  }): number | null {
+    if (!data.statusPageGroup.showUptimePercent) {
+      return null;
+    }
+
+    const resourcesInGroup: Array<StatusPageResource> =
+      this.getResourcesInStatusPageGroup({
+        statusPageGroup: data.statusPageGroup,
+        statusPageResources: data.statusPageResources,
+      });
+
+    if (resourcesInGroup.length === 0) {
+      return null; // no resources in group.
+    }
+
+    const uptimePercentPerResource: Array<number> = [];
+
+    for (const resource of resourcesInGroup) {
+      const calculateUptimePercentOfResource: number | null =
+        this.calculateUptimePercentOfResource({
+          statusPageResource: resource,
+          monitorStatusTimelines: data.monitorStatusTimelines,
+          precision: data.precision,
+          downtimeMonitorStatuses: data.downtimeMonitorStatuses,
+          monitorsInGroup: data.monitorsInGroup,
+        });
+
+      if (calculateUptimePercentOfResource !== null) {
+        uptimePercentPerResource.push(calculateUptimePercentOfResource);
+      }
+    }
+
+    // calculate avg
+
+    if (uptimePercentPerResource.length === 0) {
+      return null;
+    }
+
+    const averageUptimePercentage: number =
+      uptimePercentPerResource.reduce((a: number, b: number) => {
+        return a + b;
+      }) / uptimePercentPerResource.length;
+
+    // if the current status is operational then show uptime Percent.
+
+    let precision: UptimePrecision = UptimePrecision.ONE_DECIMAL;
+
+    if (data.statusPageGroup.uptimePercentPrecision) {
+      precision = data.statusPageGroup.uptimePercentPrecision;
+    }
+
+    return UptimeUtil.roundToPrecision({
+      number: averageUptimePercentage,
+      precision: precision,
+    });
+  }
+
+  public static getResourcesWithoutStatusPageGroup(data: {
+    statusPageResources: Array<StatusPageResource>;
+  }): Array<StatusPageResource> {
+    return data.statusPageResources.filter((resource: StatusPageResource) => {
+      return !resource.statusPageGroupId;
+    });
+  }
+
+  public static getResourcesInStatusPageGroup(data: {
+    statusPageGroup: StatusPageGroup;
+    statusPageResources: Array<StatusPageResource>;
+  }): Array<StatusPageResource> {
+    return data.statusPageResources.filter((resource: StatusPageResource) => {
+      return (
+        resource.statusPageGroupId?.toString() ===
+        data.statusPageGroup._id?.toString()
+      );
+    });
+  }
+
+  public static calculateAvgUptimePercentageOfAllResources(data: {
+    monitorStatusTimelines: Array<MonitorStatusTimeline>;
+    precision: UptimePrecision;
+    downtimeMonitorStatuses: Array<MonitorStatus>;
+    statusPageResources: Array<StatusPageResource>;
+    resourceGroups: Array<StatusPageGroup>;
+    monitorsInGroup: Dictionary<Array<ObjectID>>;
+  }): number | null {
+    const showUptimePercentage: boolean = Boolean(
+      data.statusPageResources.find((item: StatusPageResource) => {
+        return item.showUptimePercent || item.showStatusHistoryChart;
+      }),
+    );
+
+    if (!showUptimePercentage) {
+      return null;
+    }
+
+    const allUptimePercent: Array<number> = [];
+
+    // calculate for groups first.
+
+    for (const group of data.resourceGroups) {
+      const calculateAvgUptimePercentOfStatusPageGroup: number | null =
+        this.calculateAvgUptimePercentOfStatusPageGroup({
+          statusPageGroup: group,
+          monitorStatusTimelines: data.monitorStatusTimelines,
+          precision: data.precision,
+          downtimeMonitorStatuses: data.downtimeMonitorStatuses,
+          statusPageResources: data.statusPageResources,
+          monitorsInGroup: data.monitorsInGroup,
+        });
+
+      if (calculateAvgUptimePercentOfStatusPageGroup !== null) {
+        allUptimePercent.push(calculateAvgUptimePercentOfStatusPageGroup);
+      }
+    }
+
+    // now fetch resources without group.
+
+    const resourcesWithoutGroup: Array<StatusPageResource> =
+      this.getResourcesWithoutStatusPageGroup({
+        statusPageResources: data.statusPageResources,
+      });
+
+    for (const resource of resourcesWithoutGroup) {
+      const calculateUptimePercentOfResource: number | null =
+        this.calculateUptimePercentOfResource({
+          statusPageResource: resource,
+          monitorStatusTimelines: data.monitorStatusTimelines,
+          precision: data.precision,
+          downtimeMonitorStatuses: data.downtimeMonitorStatuses,
+          monitorsInGroup: data.monitorsInGroup,
+        });
+
+      if (calculateUptimePercentOfResource !== null) {
+        allUptimePercent.push(calculateUptimePercentOfResource);
+      }
+    }
+
+    // calculate avg
+
+    if (allUptimePercent.length === 0) {
+      return null;
+    }
+
+    const averageUptimePercentage: number =
+      allUptimePercent.reduce((a: number, b: number) => {
+        return a + b;
+      }) / allUptimePercent.length;
+
+    return UptimeUtil.roundToPrecision({
+      number: averageUptimePercentage,
+      precision: data.precision,
+    });
+  }
+}

package/Utils/Uptime/UptimeUtil.ts

@@ -5,8 +5,6 @@ import OneUptimeDate from "../../Types/Date";
 import ObjectID from "../../Types/ObjectID";
 import MonitorStatus from "../../Models/DatabaseModels/MonitorStatus";
 import MonitorStatusTimeline from "../../Models/DatabaseModels/MonitorStatusTimeline";
-import StatusPageResource from "../../Models/DatabaseModels/StatusPageResource";
-import Dictionary from "../../Types/Dictionary";
 import UptimePrecision from "../../Types/StatusPage/UptimePrecision";
 
 export default class UptimeUtil {
@@ -301,111 +299,29 @@ export default class UptimeUtil {
     };
   }
 
-  public static calculateAvgUptimePercentageOfAllResources(data: {
-    monitorStatusTimelines: Array<MonitorStatusTimeline>;
+  public static roundToPrecision(data: {
+    number: number;
     precision: UptimePrecision;
-    downtimeMonitorStatuses: Array<MonitorStatus>;
-    statusPageResources: Array<StatusPageResource>;
-    monitorsInGroup: Dictionary<Array<ObjectID>>;
-  }): number | null {
-    const showUptimePercentage: boolean = Boolean(
-      data.statusPageResources.find((item: StatusPageResource) => {
-        return item.showUptimePercent || item.showStatusHistoryChart;
-      }),
-    );
-
-    if (!showUptimePercentage) {
-      return null;
-    }
-
-    const uptimePercentPerResource: Array<number> = [];
-
-    for (const resource of data.statusPageResources) {
-      if (!resource.showUptimePercent && !resource.showStatusHistoryChart) {
-        continue;
-      }
-
-      let timelinesForThisResource: Array<MonitorStatusTimeline> = [];
-
-      if (resource.monitorGroupId) {
-        timelinesForThisResource = [...data.monitorStatusTimelines].filter(
-          (timeline: MonitorStatusTimeline) => {
-            const monitorsInThisGroup: Array<ObjectID> | undefined =
-              data.monitorsInGroup[resource.monitorGroupId?.toString() || ""];
-
-            if (!monitorsInThisGroup) {
-              return false;
-            }
-
-            return monitorsInThisGroup.find((monitorId: ObjectID) => {
-              return monitorId.toString() === timeline.monitorId?.toString();
-            });
-          },
-        );
-      }
-
-      if (resource.monitorId || resource.monitor?.id) {
-        const monitorId: ObjectID | null | undefined =
-          resource.monitorId || resource.monitor?.id;
-
-        if (!monitorId) {
-          // this should never happen.
-          continue;
-        }
-
-        timelinesForThisResource = [...data.monitorStatusTimelines].filter(
-          (timeline: MonitorStatusTimeline) => {
-            return (
-              timeline.monitorId?.toString() === resource.monitorId?.toString()
-            );
-          },
-        );
-      }
-
-      const uptimePercent: number = this.calculateUptimePercentage(
-        timelinesForThisResource,
-        data.precision,
-        data.downtimeMonitorStatuses,
-      );
-
-      uptimePercentPerResource.push(uptimePercent);
-    }
-
-    // calculate avg
-
-    if (uptimePercentPerResource.length === 0) {
-      return null;
-    }
-
-    const averageUptimePercentage: number =
-      uptimePercentPerResource.reduce((a: number, b: number) => {
-        return a + b;
-      }) / uptimePercentPerResource.length;
+  }): number {
+    const { number, precision } = data;
 
-    //round this to precision.
-
-    if (data.precision === UptimePrecision.NO_DECIMAL) {
-      const percent: number = Math.round(averageUptimePercentage);
-
-      return percent;
+    if (precision === UptimePrecision.NO_DECIMAL) {
+      return Math.floor(number);
     }
 
-    if (data.precision === UptimePrecision.ONE_DECIMAL) {
-      const percent: number = Math.round(averageUptimePercentage * 10) / 10;
-      return percent;
+    if (precision === UptimePrecision.ONE_DECIMAL) {
+      return Math.floor(number * 10) / 10;
     }
 
-    if (data.precision === UptimePrecision.TWO_DECIMAL) {
-      const percent: number = Math.round(averageUptimePercentage * 100) / 100;
-      return percent;
+    if (precision === UptimePrecision.TWO_DECIMAL) {
+      return Math.floor(number * 100) / 100;
     }
 
-    if (data.precision === UptimePrecision.THREE_DECIMAL) {
-      const percent: number = Math.round(averageUptimePercentage * 1000) / 1000;
-      return percent;
+    if (precision === UptimePrecision.THREE_DECIMAL) {
+      return Math.floor(number * 1000) / 1000;
     }
 
-    return averageUptimePercentage;
+    return number;
   }
 
   public static calculateUptimePercentage(
@@ -434,42 +350,9 @@ export default class UptimeUtil {
         totalSecondsInTimePeriod) *
       100;
 
-    if (precision === UptimePrecision.NO_DECIMAL) {
-      const noDecimalPercent: number = Math.round(percentage);
-      if (noDecimalPercent === 100 && totalDowntimeInSeconds > 0) {
-        return 99;
-      }
-
-      return noDecimalPercent;
-    }
-
-    if (precision === UptimePrecision.ONE_DECIMAL) {
-      const noDecimalPercent: number = Math.round(percentage * 10) / 10;
-      if (noDecimalPercent === 100 && totalDowntimeInSeconds > 0) {
-        return 99.9;
-      }
-
-      return noDecimalPercent;
-    }
-
-    if (precision === UptimePrecision.TWO_DECIMAL) {
-      const noDecimalPercent: number = Math.round(percentage * 100) / 100;
-      if (noDecimalPercent === 100 && totalDowntimeInSeconds > 0) {
-        return 99.99;
-      }
-
-      return noDecimalPercent;
-    }
-
-    if (precision === UptimePrecision.THREE_DECIMAL) {
-      const noDecimalPercent: number = Math.round(percentage * 1000) / 1000;
-      if (noDecimalPercent === 100 && totalDowntimeInSeconds > 0) {
-        return 99.999;
-      }
-
-      return noDecimalPercent;
-    }
-
-    return percentage;
+    return this.roundToPrecision({
+      number: percentage,
+      precision,
+    });
   }
 }