@oneuptime/common 11.7.0 → 11.7.2

package/Tests/Utils/StatusPage/ResourceUptime.test.ts

@@ -0,0 +1,263 @@
+import StatusPageResourceUptimeUtil from "../../../Utils/StatusPage/ResourceUptime";
+import { Green, Red, Yellow } from "../../../Types/BrandColors";
+import ObjectID from "../../../Types/ObjectID";
+import Dictionary from "../../../Types/Dictionary";
+import MonitorStatus from "../../../Models/DatabaseModels/MonitorStatus";
+import MonitorStatusTimeline from "../../../Models/DatabaseModels/MonitorStatusTimeline";
+import StatusPageResource from "../../../Models/DatabaseModels/StatusPageResource";
+import StatusPageGroup from "../../../Models/DatabaseModels/StatusPageGroup";
+
+const MONITOR_A: ObjectID = new ObjectID(
+  "11111111-1111-4111-8111-111111111111",
+);
+const MONITOR_B: ObjectID = new ObjectID(
+  "22222222-2222-4222-8222-222222222222",
+);
+const MONITOR_C: ObjectID = new ObjectID(
+  "33333333-3333-4333-8333-333333333333",
+);
+const GROUP_ONE: ObjectID = new ObjectID(
+  "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa",
+);
+const GROUP_TWO: ObjectID = new ObjectID(
+  "bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb",
+);
+
+function makeStatus(data: {
+  name: string;
+  priority: number;
+  color: typeof Green;
+}): MonitorStatus {
+  const status: MonitorStatus = new MonitorStatus();
+  status.name = data.name;
+  status.priority = data.priority;
+  status.color = data.color;
+  return status;
+}
+
+function makeResourceForMonitor(monitorId: ObjectID): StatusPageResource {
+  const resource: StatusPageResource = new StatusPageResource();
+  resource.monitorId = monitorId;
+  return resource;
+}
+
+function makeTimelineForMonitor(monitorId: ObjectID): MonitorStatusTimeline {
+  const timeline: MonitorStatusTimeline = new MonitorStatusTimeline();
+  timeline.monitorId = monitorId;
+  return timeline;
+}
+
+describe("StatusPageResourceUptimeUtil", () => {
+  describe("getWorstMonitorStatus", () => {
+    test("defaults to Operational when there are no statuses", () => {
+      const worst: MonitorStatus =
+        StatusPageResourceUptimeUtil.getWorstMonitorStatus({
+          monitorStatuses: [],
+        });
+
+      expect(worst.name).toBe("Operational");
+      expect(worst.color).toEqual(Green);
+    });
+
+    test("returns the highest priority (worst) status", () => {
+      const operational: MonitorStatus = makeStatus({
+        name: "Operational",
+        priority: 1,
+        color: Green,
+      });
+      const degraded: MonitorStatus = makeStatus({
+        name: "Degraded",
+        priority: 2,
+        color: Yellow,
+      });
+      const offline: MonitorStatus = makeStatus({
+        name: "Offline",
+        priority: 3,
+        color: Red,
+      });
+
+      const worst: MonitorStatus =
+        StatusPageResourceUptimeUtil.getWorstMonitorStatus({
+          monitorStatuses: [operational, offline, degraded],
+        });
+
+      expect(worst.name).toBe("Offline");
+      expect(worst.priority).toBe(3);
+    });
+
+    test("a single status wins over the operational default", () => {
+      const degraded: MonitorStatus = makeStatus({
+        name: "Degraded",
+        priority: 5,
+        color: Yellow,
+      });
+
+      const worst: MonitorStatus =
+        StatusPageResourceUptimeUtil.getWorstMonitorStatus({
+          monitorStatuses: [degraded],
+        });
+
+      expect(worst.name).toBe("Degraded");
+    });
+  });
+
+  describe("getResourcesInStatusPageGroup", () => {
+    test("returns only resources whose group id matches", () => {
+      const group: StatusPageGroup = new StatusPageGroup();
+      group._id = GROUP_ONE.toString();
+
+      const inGroup: StatusPageResource = new StatusPageResource();
+      inGroup.statusPageGroupId = GROUP_ONE;
+
+      const otherGroup: StatusPageResource = new StatusPageResource();
+      otherGroup.statusPageGroupId = GROUP_TWO;
+
+      const noGroup: StatusPageResource = new StatusPageResource();
+
+      const result: Array<StatusPageResource> =
+        StatusPageResourceUptimeUtil.getResourcesInStatusPageGroup({
+          statusPageGroup: group,
+          statusPageResources: [inGroup, otherGroup, noGroup],
+        });
+
+      expect(result).toHaveLength(1);
+      expect(result[0]).toBe(inGroup);
+    });
+
+    test("returns an empty array when nothing matches", () => {
+      const group: StatusPageGroup = new StatusPageGroup();
+      group._id = GROUP_ONE.toString();
+
+      const otherGroup: StatusPageResource = new StatusPageResource();
+      otherGroup.statusPageGroupId = GROUP_TWO;
+
+      expect(
+        StatusPageResourceUptimeUtil.getResourcesInStatusPageGroup({
+          statusPageGroup: group,
+          statusPageResources: [otherGroup],
+        }),
+      ).toHaveLength(0);
+    });
+  });
+
+  describe("getResourcesWithoutStatusPageGroup", () => {
+    test("returns only ungrouped resources", () => {
+      const grouped: StatusPageResource = new StatusPageResource();
+      grouped.statusPageGroupId = GROUP_ONE;
+
+      const ungroupedA: StatusPageResource = new StatusPageResource();
+      const ungroupedB: StatusPageResource = new StatusPageResource();
+
+      const result: Array<StatusPageResource> =
+        StatusPageResourceUptimeUtil.getResourcesWithoutStatusPageGroup({
+          statusPageResources: [grouped, ungroupedA, ungroupedB],
+        });
+
+      expect(result).toHaveLength(2);
+      expect(result).toContain(ungroupedA);
+      expect(result).toContain(ungroupedB);
+      expect(result).not.toContain(grouped);
+    });
+
+    test("grouped and ungrouped partitions are complementary", () => {
+      const group: StatusPageGroup = new StatusPageGroup();
+      group._id = GROUP_ONE.toString();
+
+      const grouped: StatusPageResource = new StatusPageResource();
+      grouped.statusPageGroupId = GROUP_ONE;
+      const ungrouped: StatusPageResource = new StatusPageResource();
+
+      const all: Array<StatusPageResource> = [grouped, ungrouped];
+
+      const withoutGroup: Array<StatusPageResource> =
+        StatusPageResourceUptimeUtil.getResourcesWithoutStatusPageGroup({
+          statusPageResources: all,
+        });
+      const inGroup: Array<StatusPageResource> =
+        StatusPageResourceUptimeUtil.getResourcesInStatusPageGroup({
+          statusPageGroup: group,
+          statusPageResources: all,
+        });
+
+      expect(withoutGroup.length + inGroup.length).toBe(all.length);
+    });
+  });
+
+  describe("getMonitorStatusTimelineForResource", () => {
+    test("filters timelines to the resource's own monitor", () => {
+      const resource: StatusPageResource = makeResourceForMonitor(MONITOR_A);
+
+      const result: Array<MonitorStatusTimeline> =
+        StatusPageResourceUptimeUtil.getMonitorStatusTimelineForResource({
+          statusPageResource: resource,
+          monitorStatusTimelines: [
+            makeTimelineForMonitor(MONITOR_A),
+            makeTimelineForMonitor(MONITOR_B),
+            makeTimelineForMonitor(MONITOR_A),
+          ],
+          monitorsInGroup: {},
+        });
+
+      expect(result).toHaveLength(2);
+      for (const timeline of result) {
+        expect(timeline.monitorId?.toString()).toBe(MONITOR_A.toString());
+      }
+    });
+
+    test("resolves a monitor-group resource to all monitors in the group", () => {
+      const resource: StatusPageResource = new StatusPageResource();
+      resource.monitorGroupId = GROUP_ONE;
+
+      const monitorsInGroup: Dictionary<Array<ObjectID>> = {
+        [GROUP_ONE.toString()]: [MONITOR_A, MONITOR_B],
+      };
+
+      const result: Array<MonitorStatusTimeline> =
+        StatusPageResourceUptimeUtil.getMonitorStatusTimelineForResource({
+          statusPageResource: resource,
+          monitorStatusTimelines: [
+            makeTimelineForMonitor(MONITOR_A),
+            makeTimelineForMonitor(MONITOR_B),
+            makeTimelineForMonitor(MONITOR_C),
+          ],
+          monitorsInGroup,
+        });
+
+      // MONITOR_C is not part of the group, so it is excluded.
+      expect(result).toHaveLength(2);
+      const ids: Array<string> = result.map((t: MonitorStatusTimeline) => {
+        return t.monitorId!.toString();
+      });
+      expect(ids).toContain(MONITOR_A.toString());
+      expect(ids).toContain(MONITOR_B.toString());
+      expect(ids).not.toContain(MONITOR_C.toString());
+    });
+
+    test("returns nothing when the group has no known monitors", () => {
+      const resource: StatusPageResource = new StatusPageResource();
+      resource.monitorGroupId = GROUP_ONE;
+
+      const result: Array<MonitorStatusTimeline> =
+        StatusPageResourceUptimeUtil.getMonitorStatusTimelineForResource({
+          statusPageResource: resource,
+          monitorStatusTimelines: [makeTimelineForMonitor(MONITOR_A)],
+          monitorsInGroup: {},
+        });
+
+      expect(result).toHaveLength(0);
+    });
+
+    test("returns nothing when the resource has neither monitor nor group", () => {
+      const resource: StatusPageResource = new StatusPageResource();
+
+      const result: Array<MonitorStatusTimeline> =
+        StatusPageResourceUptimeUtil.getMonitorStatusTimelineForResource({
+          statusPageResource: resource,
+          monitorStatusTimelines: [makeTimelineForMonitor(MONITOR_A)],
+          monitorsInGroup: {},
+        });
+
+      expect(result).toHaveLength(0);
+    });
+  });
+});

package/Types/Date.ts

@@ -12,6 +12,13 @@ export const Moment: typeof moment = moment;
 export default class OneUptimeDate {
   // get date time from unix timestamp
 
+  /*
+   * The timezone the signed-in user configured in User Settings, pushed in by
+   * the UI (see UserUtil.initializeUserTimezone). Null on the server and on
+   * signed-out pages, where the process / browser zone is used instead.
+   */
+  private static userTimezone: Timezone | null = null;
+
   private static padDatePart(value: number): string {
     return value.toString().padStart(2, "0");
   }
@@ -44,6 +51,7 @@ export default class OneUptimeDate {
   private static getLocalShortMonthName(date: Date): string {
     return date.toLocaleString("default", {
       month: "short",
+      timeZone: this.getCurrentTimezone().toString(),
     });
   }
 
@@ -156,6 +164,19 @@ export default class OneUptimeDate {
     return this.getLocalTimeString(date);
   }
 
+  /**
+   * The hour / minute `date` reads at in the current timezone. Time pickers use
+   * these instead of Date.getHours()/getMinutes() so the digits they show are
+   * the ones the user expects in the zone they configured.
+   */
+  public static getLocalHours(date: Date | string): number {
+    return this.inCurrentTimezone(date).hours();
+  }
+
+  public static getLocalMinutes(date: Date | string): number {
+    return this.inCurrentTimezone(date).minutes();
+  }
+
   public static getLocalShortMonthNameFromDate(date: Date | string): string {
     date = this.fromString(date);
     return this.getLocalShortMonthName(date);
@@ -172,26 +193,27 @@ export default class OneUptimeDate {
 
     const includeMinutes: boolean = options?.includeMinutes ?? true;
     const includeSeconds: boolean = options?.includeSeconds ?? false;
-    const hours: string = this.padDatePart(date.getHours());
+    const localDate: moment.Moment = this.inCurrentTimezone(date);
+    const hours: string = this.padDatePart(localDate.hours());
 
     if (!includeMinutes) {
       return hours;
     }
 
-    const minutes: string = this.padDatePart(date.getMinutes());
+    const minutes: string = this.padDatePart(localDate.minutes());
 
     if (!includeSeconds) {
       return `${hours}:${minutes}`;
     }
 
-    const seconds: string = this.padDatePart(date.getSeconds());
+    const seconds: string = this.padDatePart(localDate.seconds());
     return `${hours}:${minutes}:${seconds}`;
   }
 
   public static getDateAsLocalDayMonthString(date: Date | string): string {
     date = this.fromString(date);
 
-    const day: string = this.padDatePart(date.getDate());
+    const day: string = this.padDatePart(this.inCurrentTimezone(date).date());
     const month: string = this.getLocalShortMonthName(date);
 
     return `${day} ${month}`;
@@ -207,7 +229,7 @@ export default class OneUptimeDate {
     date = this.fromString(date);
 
     const month: string = this.getLocalShortMonthName(date);
-    const year: string = date.getFullYear().toString();
+    const year: string = this.inCurrentTimezone(date).year().toString();
 
     return `${month} ${year}`;
   }
@@ -316,7 +338,7 @@ export default class OneUptimeDate {
       : `${datePart}, ${timePart}`;
 
     if (!data.timezone) {
-      const local: moment.Moment = moment(date).local();
+      const local: moment.Moment = this.inCurrentTimezone(date);
       return (
         local.format(formatString) +
         (data.onlyShowDate ? "" : " " + this.getCurrentTimezoneString())
@@ -333,18 +355,18 @@ export default class OneUptimeDate {
   }
 
   /**
-   * Reinterpret the wall-clock components of `date` — read in the process /
-   * browser local zone — as the SAME wall-clock in `timezone`, and return that
-   * instant. Used to store a time the user typed for the schedule's timezone
-   * even though the time picker captured it in the browser's local zone (audit
-   * F1). Inverse of getLocalDateFromWallClockInTimezone.
+   * Reinterpret the wall-clock components of `date` — read in the CURRENT
+   * timezone, i.e. the one the pickers render in — as the SAME wall-clock in
+   * `timezone`, and return that instant. Used to store a time the user typed
+   * for the schedule's timezone even though the time picker captured it in the
+   * viewer's own zone (audit F1). Inverse of
+   * getLocalDateFromWallClockInTimezone.
    */
   public static getInstantFromLocalWallClockInTimezone(
     date: Date | string,
     timezone: string,
   ): Date {
-    date = this.fromString(date);
-    const local: moment.Moment = moment(date);
+    const local: moment.Moment = this.inCurrentTimezone(date);
     return moment
       .tz(
         {
@@ -361,10 +383,10 @@ export default class OneUptimeDate {
   }
 
   /**
-   * Inverse of getInstantFromLocalWallClockInTimezone: return a process /
-   * browser local Date whose LOCAL wall-clock equals `date`'s wall-clock as seen
-   * in `timezone`. Used to display a stored schedule-timezone time inside a
-   * browser-local time picker (audit F1).
+   * Inverse of getInstantFromLocalWallClockInTimezone: return a Date whose
+   * wall-clock IN THE CURRENT TIMEZONE equals `date`'s wall-clock as seen in
+   * `timezone`. Used to display a stored schedule-timezone time inside a picker
+   * that renders in the viewer's own zone (audit F1).
    */
   public static getLocalDateFromWallClockInTimezone(
     date: Date | string,
@@ -372,14 +394,19 @@ export default class OneUptimeDate {
   ): Date {
     date = this.fromString(date);
     const zoned: moment.Moment = moment.tz(date, timezone);
-    return moment({
-      year: zoned.year(),
-      month: zoned.month(),
-      day: zoned.date(),
-      hour: zoned.hour(),
-      minute: zoned.minute(),
-      second: zoned.second(),
-    }).toDate();
+    return moment
+      .tz(
+        {
+          year: zoned.year(),
+          month: zoned.month(),
+          day: zoned.date(),
+          hour: zoned.hour(),
+          minute: zoned.minute(),
+          second: zoned.second(),
+        },
+        this.getCurrentTimezone().toString(),
+      )
+      .toDate();
   }
 
   public static isOverlapping(
@@ -709,22 +736,26 @@ export default class OneUptimeDate {
     return this.addRemoveMinutes(date, date.getTimezoneOffset());
   }
 
+  /**
+   * Render an instant as the value of an `<input type="datetime-local">` — a
+   * bare wall-clock with no offset — read in the current timezone.
+   */
   public static toDateTimeLocalString(date: Date): string {
-    date = this.fromString(date);
-
-    type TenFunction = (i: number) => string;
-
-    const ten: TenFunction = (i: number): string => {
-        return (i < 10 ? "0" : "") + i;
-      },
-      YYYY: number = date.getFullYear(),
-      MM: string = ten(date.getMonth() + 1),
-      DD: string = ten(date.getDate()),
-      HH: string = ten(date.getHours()),
-      II: string = ten(date.getMinutes()),
-      SS: string = ten(date.getSeconds());
+    return this.inCurrentTimezone(date).format("YYYY-MM-DDTHH:mm:ss");
+  }
 
-    return YYYY + "-" + MM + "-" + DD + "T" + HH + ":" + II + ":" + SS;
+  /**
+   * Inverse of toDateTimeLocalString: turn the offset-less wall-clock a user
+   * typed into a `<input type="date">` / `<input type="datetime-local">` into
+   * the instant it names in the current timezone. Without this the browser
+   * zone is used to resolve the wall-clock, so a user whose machine reports a
+   * different zone than the one they configured would have their times stored
+   * hours off.
+   */
+  public static fromDateTimeLocalString(value: string): Date {
+    return moment
+      .tz(value.trim(), this.getCurrentTimezone().toString())
+      .toDate();
   }
 
   public static fromJSON(json: JSONObject): Date {
@@ -1713,7 +1744,7 @@ export default class OneUptimeDate {
       formatstring = "MMM DD, YYYY";
     }
 
-    const momentDate: moment.Moment = moment(date).local();
+    const momentDate: moment.Moment = this.inCurrentTimezone(date);
 
     return (
       momentDate.format(formatstring) +
@@ -1752,8 +1783,41 @@ export default class OneUptimeDate {
     return zoneAbbr;
   }
 
+  /**
+   * Set the timezone the signed-in user picked in User Settings. Once set,
+   * every "local" helper below resolves wall-clock times in THIS zone instead
+   * of the zone the browser reports, so what the user reads and types matches
+   * the timezone they configured — even when the machine, OS or VPN they are
+   * on reports a different one. Pass null to fall back to the browser zone
+   * (signed-out surfaces, or a user who has not picked a timezone).
+   */
+  public static setUserTimezone(timezone: Timezone | null | undefined): void {
+    /*
+     * Ignore anything moment does not recognise as an IANA zone. A stale or
+     * corrupt saved value must not take every date in the UI down with it.
+     */
+    if (!timezone || !moment.tz.zone(timezone.toString())) {
+      this.userTimezone = null;
+      return;
+    }
+
+    this.userTimezone = timezone;
+  }
+
+  public static getUserTimezone(): Timezone | null {
+    return this.userTimezone;
+  }
+
   public static getCurrentTimezone(): Timezone {
-    return moment.tz.guess() as Timezone;
+    return this.userTimezone || (moment.tz.guess() as Timezone);
+  }
+
+  /**
+   * The instant `date` viewed through the current timezone — the single place
+   * that decides which wall clock the "local" helpers below read from.
+   */
+  private static inCurrentTimezone(date: Date | string): moment.Moment {
+    return moment(this.fromString(date)).tz(this.getCurrentTimezone());
   }
 
   public static getDateString(date: Date): string {
@@ -1810,9 +1874,8 @@ export default class OneUptimeDate {
   }
 
   public static asDateForDatabaseQuery(date: string | Date): string {
-    date = this.fromString(date);
     const formatstring: string = "YYYY-MM-DD";
-    return moment(date).local().format(formatstring);
+    return this.inCurrentTimezone(date).format(formatstring);
   }
 
   public static asFilterDateForDatabaseQuery(
@@ -1850,13 +1913,19 @@ export default class OneUptimeDate {
       throw new BadDataException("Invalid seconds");
     }
 
-    const date: Date = OneUptimeDate.getCurrentDate();
-
-    date.setHours(hour);
-    date.setMinutes(minutes);
-    date.setSeconds(seconds);
-
-    return date;
+    /*
+     * The hour/minute the user picked is a wall-clock reading in THEIR
+     * timezone, so anchor it to today's date in that zone rather than setting
+     * it on a browser-local Date.
+     */
+    return this.inCurrentTimezone(OneUptimeDate.getCurrentDate())
+      .set({
+        hour: hour,
+        minute: minutes,
+        second: seconds,
+        millisecond: 0,
+      })
+      .toDate();
   }
 
   public static toDatabaseDate(date: Date): string {

package/Types/Workspace/NotificationRules/BaseNotificationRule.ts

@@ -10,4 +10,8 @@ export default interface BaseNotificationRule {
   shouldPostToExistingChannel: boolean;
   existingChannelNames: string; // separate by comma
   existingTeam?: string; // team to post to (for MS Teams only)
+
+  // Post to group / personal chats (for MS Teams only).
+  shouldPostToExistingChat?: boolean;
+  existingChatIds?: Array<string>; // Teams chat ids the OneUptime app has been added to.
 }

package/Types/Workspace/NotificationRules/NotificationRuleCondition.ts

@@ -9,7 +9,7 @@ import ScheduledMaintenanceState from "../../../Models/DatabaseModels/ScheduledM
 import { DropdownOption } from "../../../UI/Components/Dropdown/Dropdown";
 import DropdownUtil from "../../../UI/Utils/Dropdown";
 import MonitorType from "../../Monitor/MonitorType";
-import WorkspaceType from "../WorkspaceType";
+import WorkspaceType, { getWorkspaceTypeDisplayName } from "../WorkspaceType";
 import NotificationRuleEventType from "./EventType";
 import IncidentNotificationRule from "./NotificationRuleTypes/IncidentNotificationRule";
 
@@ -108,32 +108,47 @@ export class NotificationRuleConditionUtil {
       eventType === NotificationRuleEventType.IncidentEpisode ||
       eventType === NotificationRuleEventType.ScheduledMaintenance
     ) {
-      // either create slack channel or select existing one should be active.
+      // either create a channel, post to an existing channel, or post to a chat.
+
+      const workspaceDisplayName: string =
+        getWorkspaceTypeDisplayName(workspaceType);
 
       if (
         !notificationRule.shouldCreateNewChannel &&
-        !notificationRule.shouldPostToExistingChannel
+        !notificationRule.shouldPostToExistingChannel &&
+        !notificationRule.shouldPostToExistingChat
       ) {
-        return (
-          "Please select either create slack channel or post to existing " +
-          workspaceType +
-          " channel"
-        );
+        return workspaceType === WorkspaceType.MicrosoftTeams
+          ? `Please select a destination: create a ${workspaceDisplayName} channel, post to an existing ${workspaceDisplayName} channel, or post to an existing ${workspaceDisplayName} chat`
+          : `Please select a destination: create a ${workspaceDisplayName} channel or post to an existing ${workspaceDisplayName} channel`;
       }
 
       if (notificationRule.shouldPostToExistingChannel) {
         if (!notificationRule.existingChannelNames?.trim()) {
-          return "Existing " + workspaceType + " channel name is required";
+          return (
+            "Existing " + workspaceDisplayName + " channel name is required"
+          );
         }
       }
 
       if (notificationRule.shouldCreateNewChannel) {
         if (!notificationRule.newChannelTemplateName?.trim()) {
-          return "New " + workspaceType + " channel name is required";
+          return "New " + workspaceDisplayName + " channel name is required";
         }
       }
     }
 
+    if (notificationRule.shouldPostToExistingChat) {
+      if (
+        !notificationRule.existingChatIds ||
+        notificationRule.existingChatIds.length === 0
+      ) {
+        const workspaceDisplayName: string =
+          getWorkspaceTypeDisplayName(workspaceType);
+        return `Please select at least one ${workspaceDisplayName} chat to post to. If no chats are listed, add the OneUptime app to a chat in ${workspaceDisplayName} first.`;
+      }
+    }
+
     return null;
   }
 

package/Types/Workspace/WorkspaceMessagePayload.ts

@@ -106,4 +106,5 @@ export default interface WorkspaceMessagePayload {
   messageBlocks: Array<WorkspaceMessageBlock>; // Message to add to blocks.
   workspaceType: WorkspaceType;
   teamId?: string | undefined; // Team ID for Microsoft Teams
+  chatIds?: Array<string> | undefined; // Microsoft Teams chat ids (group / personal chats) to send message to.
 }