@oneuptime/common 7.0.2525 → 7.0.2570

package/build/dist/Types/Date.js

@@ -1,9 +1,10 @@
-import InBetween from './BaseDatabase/InBetween';
-import DayOfWeek, { DayOfWeekUtil } from './Day/DayOfWeek';
-import BadDataException from './Exception/BadDataException';
-import { ObjectType } from './JSON';
-import PositiveNumber from './PositiveNumber';
-import moment from 'moment-timezone';
+import InBetween from "./BaseDatabase/InBetween";
+import DayOfWeek, { DayOfWeekUtil } from "./Day/DayOfWeek";
+import BadDataException from "./Exception/BadDataException";
+import { ObjectType } from "./JSON";
+import PositiveNumber from "./PositiveNumber";
+import moment from "moment-timezone";
+import Timezone from "./Timezone";
 export const Moment = moment;
 export default class OneUptimeDate {
     getNanoSecondsFromSeconds(seconds) {
@@ -26,7 +27,7 @@ export default class OneUptimeDate {
     }
     static getLocalHourAndMinuteFromDate(date) {
         date = this.fromString(date);
-        return moment(date).format('HH:mm');
+        return moment(date).format("HH:mm");
     }
     static getMillisecondsBetweenTwoUnixNanoDates(startDate, endDate) {
         return endDate - startDate;
@@ -78,10 +79,10 @@ export default class OneUptimeDate {
         return this.secondsToFormattedFriendlyTimeString(seconds);
     }
     static toTimeString(date) {
-        if (typeof date === 'string') {
+        if (typeof date === "string") {
             date = this.fromString(date);
         }
-        return moment(date).format('HH:mm');
+        return moment(date).format("HH:mm");
     }
     static isSame(date1, date2) {
         date1 = this.fromString(date1);
@@ -91,7 +92,7 @@ export default class OneUptimeDate {
     static getDaysBetweenTwoDates(startDate, endDate) {
         startDate = this.fromString(startDate);
         endDate = this.fromString(endDate);
-        return moment(endDate).diff(moment(startDate), 'days');
+        return moment(endDate).diff(moment(startDate), "days");
     }
     static getDaysBetweenTwoDatesInclusive(startDate, endDate) {
         return this.getDaysBetweenTwoDates(startDate, endDate) + 1;
@@ -99,7 +100,7 @@ export default class OneUptimeDate {
     static getHoursBetweenTwoDates(startDate, endDate) {
         startDate = this.fromString(startDate);
         endDate = this.fromString(endDate);
-        return moment(endDate).diff(moment(startDate), 'hours');
+        return moment(endDate).diff(moment(startDate), "hours");
     }
     static getHoursBetweenTwoDatesInclusive(startDate, endDate) {
         return this.getHoursBetweenTwoDates(startDate, endDate) + 1;
@@ -107,7 +108,7 @@ export default class OneUptimeDate {
     static getMinutesBetweenTwoDates(startDate, endDate) {
         startDate = this.fromString(startDate);
         endDate = this.fromString(endDate);
-        return moment(endDate).diff(moment(startDate), 'minutes');
+        return moment(endDate).diff(moment(startDate), "minutes");
     }
     static getMinutesBetweenTwoDatesInclusive(startDate, endDate) {
         return this.getMinutesBetweenTwoDates(startDate, endDate) + 1;
@@ -115,7 +116,7 @@ export default class OneUptimeDate {
     static getSecondsBetweenTwoDates(startDate, endDate) {
         startDate = this.fromString(startDate);
         endDate = this.fromString(endDate);
-        return moment(endDate).diff(moment(startDate), 'seconds');
+        return moment(endDate).diff(moment(startDate), "seconds");
     }
     static getSecondsBetweenTwoDatesInclusive(startDate, endDate) {
         return this.getSecondsBetweenTwoDates(startDate, endDate) + 1;
@@ -123,7 +124,7 @@ export default class OneUptimeDate {
     static getWeeksBetweenTwoDates(startDate, endDate) {
         startDate = this.fromString(startDate);
         endDate = this.fromString(endDate);
-        return moment(endDate).diff(moment(startDate), 'weeks');
+        return moment(endDate).diff(moment(startDate), "weeks");
     }
     static getWeeksBetweenTwoDatesInclusive(startDate, endDate) {
         return this.getWeeksBetweenTwoDates(startDate, endDate) + 1;
@@ -131,7 +132,7 @@ export default class OneUptimeDate {
     static getMonthsBetweenTwoDates(startDate, endDate) {
         startDate = this.fromString(startDate);
         endDate = this.fromString(endDate);
-        return moment(endDate).diff(moment(startDate), 'months');
+        return moment(endDate).diff(moment(startDate), "months");
     }
     static getMonthsBetweenTwoDatesInclusive(startDate, endDate) {
         return this.getMonthsBetweenTwoDates(startDate, endDate) + 1;
@@ -139,14 +140,14 @@ export default class OneUptimeDate {
     static getYearsBetweenTwoDates(startDate, endDate) {
         startDate = this.fromString(startDate);
         endDate = this.fromString(endDate);
-        return moment(endDate).diff(moment(startDate), 'years');
+        return moment(endDate).diff(moment(startDate), "years");
     }
     static getYearsBetweenTwoDatesInclusive(startDate, endDate) {
         return this.getYearsBetweenTwoDates(startDate, endDate) + 1;
     }
     static toString(date) {
         if (!date) {
-            return '';
+            return "";
         }
         date = this.fromString(date);
         return date.toISOString();
@@ -186,7 +187,7 @@ export default class OneUptimeDate {
             minutes = new PositiveNumber(minutes);
         }
         return this.getCurrentMomentDate()
-            .add(-1 * minutes.toNumber(), 'minutes')
+            .add(-1 * minutes.toNumber(), "minutes")
             .toDate();
     }
     static timezoneOffsetDate(date) {
@@ -196,15 +197,15 @@ export default class OneUptimeDate {
     static toDateTimeLocalString(date) {
         date = this.fromString(date);
         const ten = (i) => {
-            return (i < 10 ? '0' : '') + i;
+            return (i < 10 ? "0" : "") + i;
         }, YYYY = date.getFullYear(), MM = ten(date.getMonth() + 1), DD = ten(date.getDate()), HH = ten(date.getHours()), II = ten(date.getMinutes()), SS = ten(date.getSeconds());
-        return YYYY + '-' + MM + '-' + DD + 'T' + HH + ':' + II + ':' + SS;
+        return YYYY + "-" + MM + "-" + DD + "T" + HH + ":" + II + ":" + SS;
     }
     static fromJSON(json) {
-        if (json['_type'] === ObjectType.DateTime) {
-            return OneUptimeDate.fromString(json['value']);
+        if (json["_type"] === ObjectType.DateTime) {
+            return OneUptimeDate.fromString(json["value"]);
         }
-        throw new BadDataException('Invalid JSON: ' + JSON.stringify(json));
+        throw new BadDataException("Invalid JSON: " + JSON.stringify(json));
     }
     static toJSON(date) {
         return {
@@ -215,65 +216,65 @@ export default class OneUptimeDate {
     static areOnTheSameDay(date1, date2) {
         date1 = this.fromString(date1);
         date2 = this.fromString(date2);
-        return moment(date1).isSame(date2, 'day');
+        return moment(date1).isSame(date2, "day");
     }
     static areOnTheSameMonth(date1, date2) {
         date1 = this.fromString(date1);
         date2 = this.fromString(date2);
-        return moment(date1).isSame(date2, 'month');
+        return moment(date1).isSame(date2, "month");
     }
     static areOnTheSameYear(date1, date2) {
         date1 = this.fromString(date1);
         date2 = this.fromString(date2);
-        return moment(date1).isSame(date2, 'year');
+        return moment(date1).isSame(date2, "year");
     }
     static areOnTheSameHour(date1, date2) {
         date1 = this.fromString(date1);
         date2 = this.fromString(date2);
-        return moment(date1).isSame(date2, 'hour');
+        return moment(date1).isSame(date2, "hour");
     }
     static areOnTheSameMinute(date1, date2) {
         date1 = this.fromString(date1);
         date2 = this.fromString(date2);
-        return moment(date1).isSame(date2, 'minute');
+        return moment(date1).isSame(date2, "minute");
     }
     static areOnTheSameSecond(date1, date2) {
         date1 = this.fromString(date1);
         date2 = this.fromString(date2);
-        return moment(date1).isSame(date2, 'second');
+        return moment(date1).isSame(date2, "second");
     }
     static areOnTheSameWeek(date1, date2) {
         date1 = this.fromString(date1);
         date2 = this.fromString(date2);
-        return moment(date1).isSame(date2, 'week');
+        return moment(date1).isSame(date2, "week");
     }
     static addRemoveMinutes(date, minutes) {
         date = this.fromString(date);
-        return moment(date).add(minutes, 'minutes').toDate();
+        return moment(date).add(minutes, "minutes").toDate();
     }
     static addRemoveDays(date, days) {
         date = this.fromString(date);
-        return moment(date).add(days, 'days').toDate();
+        return moment(date).add(days, "days").toDate();
     }
     static addRemoveHours(date, hours) {
         date = this.fromString(date);
-        return moment(date).add(hours, 'hours').toDate();
+        return moment(date).add(hours, "hours").toDate();
     }
     static addRemoveYears(date, years) {
         date = this.fromString(date);
-        return moment(date).add(years, 'years').toDate();
+        return moment(date).add(years, "years").toDate();
     }
     static addRemoveMonths(date, months) {
         date = this.fromString(date);
-        return moment(date).add(months, 'months').toDate();
+        return moment(date).add(months, "months").toDate();
     }
     static addRemoveWeeks(date, weeks) {
         date = this.fromString(date);
-        return moment(date).add(weeks, 'weeks').toDate();
+        return moment(date).add(weeks, "weeks").toDate();
     }
     static addRemoveSeconds(date, seconds) {
         date = this.fromString(date);
-        return moment(date).add(seconds, 'seconds').toDate();
+        return moment(date).add(seconds, "seconds").toDate();
     }
     static getSecondsInDays(days) {
         if (!(days instanceof PositiveNumber)) {
@@ -289,7 +290,7 @@ export default class OneUptimeDate {
             hours = new PositiveNumber(hours);
         }
         return this.getCurrentMomentDate()
-            .add(-1 * hours.toNumber(), 'hours')
+            .add(-1 * hours.toNumber(), "hours")
             .toDate();
     }
     static getSomeDaysAgo(days) {
@@ -297,7 +298,7 @@ export default class OneUptimeDate {
             days = new PositiveNumber(days);
         }
         return this.getCurrentMomentDate()
-            .add(-1 * days.toNumber(), 'days')
+            .add(-1 * days.toNumber(), "days")
             .toDate();
     }
     static getSomeDaysAgoFromDate(date, days) {
@@ -306,7 +307,7 @@ export default class OneUptimeDate {
             days = new PositiveNumber(days);
         }
         return moment(date)
-            .add(-1 * days.toNumber(), 'days')
+            .add(-1 * days.toNumber(), "days")
             .toDate();
     }
     static getSomeDaysAfterFromDate(date, days) {
@@ -314,7 +315,7 @@ export default class OneUptimeDate {
         if (!(days instanceof PositiveNumber)) {
             days = new PositiveNumber(days);
         }
-        return moment(date).add(Number(days.toNumber()), 'days').toDate();
+        return moment(date).add(Number(days.toNumber()), "days").toDate();
     }
     static getSomeDaysBeforeFromDate(date, days) {
         date = this.fromString(date);
@@ -322,7 +323,7 @@ export default class OneUptimeDate {
             days = new PositiveNumber(days);
         }
         return moment(date)
-            .add(-1 * Number(days.toNumber()), 'days')
+            .add(-1 * Number(days.toNumber()), "days")
             .toDate();
     }
     static getSomeSecondsAgo(seconds) {
@@ -330,7 +331,7 @@ export default class OneUptimeDate {
             seconds = new PositiveNumber(seconds);
         }
         return this.getCurrentMomentDate()
-            .add(-1 * seconds.toNumber(), 'seconds')
+            .add(-1 * seconds.toNumber(), "seconds")
             .toDate();
     }
     static getOneMinAfter() {
@@ -344,27 +345,23 @@ export default class OneUptimeDate {
             minutes = new PositiveNumber(minutes);
         }
         return this.getCurrentMomentDate()
-            .add(minutes.toNumber(), 'minutes')
+            .add(minutes.toNumber(), "minutes")
             .toDate();
     }
     static getSomeHoursAfter(hours) {
         if (!(hours instanceof PositiveNumber)) {
             hours = new PositiveNumber(hours);
         }
-        return this.getCurrentMomentDate()
-            .add(hours.toNumber(), 'hours')
-            .toDate();
+        return this.getCurrentMomentDate().add(hours.toNumber(), "hours").toDate();
     }
     static getSomeDaysAfter(days) {
         if (!(days instanceof PositiveNumber)) {
             days = new PositiveNumber(days);
         }
-        return this.getCurrentMomentDate()
-            .add(days.toNumber(), 'days')
-            .toDate();
+        return this.getCurrentMomentDate().add(days.toNumber(), "days").toDate();
     }
     static secondsToFormattedTimeString(seconds) {
-        return moment.utc(seconds * 1000).format('HH:mm:ss');
+        return moment.utc(seconds * 1000).format("HH:mm:ss");
     }
     static toUnixTimestamp(date) {
         return Math.floor(date.getTime() / 1000);
@@ -373,67 +370,67 @@ export default class OneUptimeDate {
         const startDate = moment.utc(0);
         const date = moment.utc(seconds * 1000);
         // get the difference between the two dates as friendly formatted string
-        let formattedString = '';
+        let formattedString = "";
         // years between two dates
-        const years = date.diff(startDate, 'years');
+        const years = date.diff(startDate, "years");
         if (years > 0) {
-            let text = 'years ';
+            let text = "years ";
             if (years === 1) {
-                text = 'year ';
+                text = "year ";
             }
             // add years to start date
-            startDate.add(years, 'years');
-            formattedString += years + ' ' + text;
+            startDate.add(years, "years");
+            formattedString += years + " " + text;
         }
-        const months = date.diff(startDate, 'months');
+        const months = date.diff(startDate, "months");
         if (months > 0) {
-            let text = 'months ';
+            let text = "months ";
             if (months === 1) {
-                text = 'month ';
+                text = "month ";
             }
             // add months to start date
-            startDate.add(months, 'months');
-            formattedString += months + ' ' + text;
+            startDate.add(months, "months");
+            formattedString += months + " " + text;
         }
-        const days = date.diff(startDate, 'days');
+        const days = date.diff(startDate, "days");
         if (days > 0) {
-            let text = 'days ';
+            let text = "days ";
             if (days === 1) {
-                text = 'day ';
+                text = "day ";
             }
             // add days to start date
-            startDate.add(days, 'days');
-            formattedString += days + ' ' + text;
+            startDate.add(days, "days");
+            formattedString += days + " " + text;
         }
-        const hours = date.diff(startDate, 'hours');
+        const hours = date.diff(startDate, "hours");
         if (hours > 0) {
-            let text = 'hours ';
+            let text = "hours ";
             if (hours === 1) {
-                text = 'hour ';
+                text = "hour ";
             }
             // add hours to start date
-            startDate.add(hours, 'hours');
-            formattedString += hours + ' ' + text;
+            startDate.add(hours, "hours");
+            formattedString += hours + " " + text;
         }
-        const minutes = date.diff(startDate, 'minutes');
+        const minutes = date.diff(startDate, "minutes");
         if (minutes > 0) {
-            let text = 'mins ';
+            let text = "mins ";
             if (minutes === 1) {
-                text = 'min ';
+                text = "min ";
             }
             // add minutes to start date
-            startDate.add(minutes, 'minutes');
-            formattedString += minutes + ' ' + text;
+            startDate.add(minutes, "minutes");
+            formattedString += minutes + " " + text;
         }
-        const secondsLeft = date.diff(startDate, 'seconds');
+        const secondsLeft = date.diff(startDate, "seconds");
         if (secondsLeft > 0) {
-            let text = 'secs ';
+            let text = "secs ";
             if (secondsLeft === 1) {
-                text = 'sec ';
+                text = "sec ";
             }
             // add seconds to start date
-            startDate.add(secondsLeft, 'seconds');
-            formattedString += secondsLeft + ' ' + text;
+            startDate.add(secondsLeft, "seconds");
+            formattedString += secondsLeft + " " + text;
         }
         return formattedString.trim();
     }
@@ -463,25 +460,25 @@ export default class OneUptimeDate {
         if (!(days instanceof PositiveNumber)) {
             days = new PositiveNumber(days);
         }
-        return moment(date).add(days.toNumber(), 'days').toDate();
+        return moment(date).add(days.toNumber(), "days").toDate();
     }
     static getSomeSecondsAfter(seconds) {
         if (!(seconds instanceof PositiveNumber)) {
             seconds = new PositiveNumber(seconds);
         }
         return this.getCurrentMomentDate()
-            .add(seconds.toNumber(), 'seconds')
+            .add(seconds.toNumber(), "seconds")
             .toDate();
     }
     static getNumberOfDaysBetweenDates(startDate, endDate) {
         const a = moment(startDate);
         const b = moment(endDate);
-        return b.diff(a, 'days');
+        return b.diff(a, "days");
     }
     static getNumberOfMinutesBetweenDates(startDate, endDate) {
         const a = moment(startDate);
         const b = moment(endDate);
-        return b.diff(a, 'minutes');
+        return b.diff(a, "minutes");
     }
     static getNumberOfDaysBetweenDatesInclusive(startDate, endDate) {
         return this.getNumberOfDaysBetweenDates(startDate, endDate) + 1;
@@ -494,11 +491,11 @@ export default class OneUptimeDate {
     }
     static getStartOfDay(date) {
         date = this.fromString(date);
-        return moment(date).startOf('day').toDate();
+        return moment(date).startOf("day").toDate();
     }
     static getEndOfDay(date) {
         date = this.fromString(date);
-        return moment(date).endOf('day').toDate();
+        return moment(date).endOf("day").toDate();
     }
     static isBetween(date, startDate, endDate) {
         date = this.fromString(date);
@@ -539,7 +536,7 @@ export default class OneUptimeDate {
         else if (dayOfWeek === 7) {
             return DayOfWeek.Sunday;
         }
-        throw new BadDataException('Invalid day of week');
+        throw new BadDataException("Invalid day of week");
     }
     static geyDayOfWeekAsNumber(date) {
         date = this.fromString(date);
@@ -553,7 +550,7 @@ export default class OneUptimeDate {
     static isEqualBySeconds(date, startDate) {
         date = this.fromString(date);
         startDate = this.fromString(startDate);
-        return moment(date).isSame(startDate, 'seconds');
+        return moment(date).isSame(startDate, "seconds");
     }
     static hasExpired(expirationDate) {
         expirationDate = this.fromString(expirationDate);
@@ -569,18 +566,18 @@ export default class OneUptimeDate {
     }
     static getDateAsFormattedString(date, onlyShowDate) {
         date = this.fromString(date);
-        let formatstring = 'MMM DD YYYY, HH:mm';
+        let formatstring = "MMM DD YYYY, HH:mm";
         if (onlyShowDate) {
-            formatstring = 'MMM DD, YYYY';
+            formatstring = "MMM DD, YYYY";
         }
         return (moment(date).format(formatstring) +
-            ' ' +
-            (onlyShowDate ? '' : this.getCurrentTimezoneString()));
+            " " +
+            (onlyShowDate ? "" : this.getCurrentTimezoneString()));
     }
     static getDifferenceInMinutes(date, date2) {
         date = this.fromString(date);
         date2 = this.fromString(date2);
-        const minutes = moment(date).diff(moment(date2), 'minutes');
+        const minutes = moment(date).diff(moment(date2), "minutes");
         if (minutes < 0) {
             return minutes * -1;
         }
@@ -591,65 +588,109 @@ export default class OneUptimeDate {
         const days = Math.floor(minutes / (24 * 60));
         const hours = Math.floor((minutes % (24 * 60)) / 60);
         const mins = minutes % 60;
-        let formattedString = '';
+        let formattedString = "";
         if (days > 0) {
-            formattedString += days + ' days';
+            formattedString += days + " days";
         }
         if (hours > 0) {
             if (formattedString.length > 0) {
-                formattedString += ', ';
+                formattedString += ", ";
             }
-            formattedString += hours + ' hours';
+            formattedString += hours + " hours";
         }
         if (mins >= 0) {
             if (formattedString.length > 0) {
-                formattedString += ', ';
+                formattedString += ", ";
             }
-            formattedString += mins + ' minutes';
+            formattedString += mins + " minutes";
         }
         return formattedString;
     }
-    static getDateAsFormattedArrayInMultipleTimezones(date, onlyShowDate) {
+    static getGmtOffsetByTimezone(timezone) {
+        return moment.tz(timezone).utcOffset();
+    }
+    static getGmtOffsetFriendlyStringByTimezone(timezone) {
+        const offset = this.getGmtOffsetByTimezone(timezone);
+        return this.getGmtOffsetFriendlyString(offset) + " " + timezone;
+    }
+    static getGmtOffsetFriendlyString(offset) {
+        const hours = Math.abs(offset) / 60;
+        const minutes = Math.abs(offset) % 60;
+        let formattedString = "GMT";
+        if (offset < 0) {
+            formattedString += "-";
+        }
+        else {
+            formattedString += "+";
+        }
+        // remove decimals from hours
+        formattedString += Math.floor(hours);
+        if (minutes > 0) {
+            formattedString += ":" + minutes;
+        }
+        return formattedString;
+    }
+    static getDateAsFormattedArrayInMultipleTimezones(data) {
+        let date = data.date;
+        const onlyShowDate = data.onlyShowDate;
+        let timezones = data.timezones;
         date = this.fromString(date);
-        let formatstring = 'MMM DD YYYY, HH:mm';
+        let formatstring = "MMM DD YYYY, HH:mm";
         if (onlyShowDate) {
-            formatstring = 'MMM DD, YYYY';
+            formatstring = "MMM DD, YYYY";
         }
         // convert this date into GMT, EST, PST, IST, ACT with moment
         const timezoneDates = [];
-        timezoneDates.push(moment(date).tz('UTC').format(formatstring) +
-            ' ' +
-            (onlyShowDate ? '' : 'GMT'));
-        timezoneDates.push(moment(date).tz('America/New_York').format(formatstring) +
-            ' ' +
-            (onlyShowDate ? '' : 'EST'));
-        timezoneDates.push(moment(date).tz('America/Los_Angeles').format(formatstring) +
-            ' ' +
-            (onlyShowDate ? '' : 'PST'));
-        timezoneDates.push(moment(date).tz('Asia/Kolkata').format(formatstring) +
-            ' ' +
-            (onlyShowDate ? '' : 'IST'));
-        timezoneDates.push(moment(date).tz('Australia/Sydney').format(formatstring) +
-            ' ' +
-            (onlyShowDate ? '' : 'AEST'));
+        if (!timezones || timezones.length === 0) {
+            timezones = [
+                Timezone.UTC,
+                Timezone.EST,
+                Timezone.AmericaLos_Angeles,
+                Timezone.AsiaKolkata,
+                Timezone.AustraliaSydney,
+            ]; // default timezones.
+        }
+        for (let i = 0; i < timezones.length; i++) {
+            timezoneDates.push(moment(date)
+                .tz(timezones[i])
+                .format(formatstring) +
+                " " +
+                (onlyShowDate
+                    ? ""
+                    : this.getZoneAbbrByTimezone(timezones[i])));
+        }
         return timezoneDates;
     }
-    static getDateAsFormattedHTMLInMultipleTimezones(date, onlyShowDate) {
-        return this.getDateAsFormattedArrayInMultipleTimezones(date, onlyShowDate).join('<br/>');
-    }
-    static getDateAsFormattedStringInMultipleTimezones(date, onlyShowDate) {
-        return this.getDateAsFormattedArrayInMultipleTimezones(date, onlyShowDate).join('\n');
+    static getDateAsFormattedHTMLInMultipleTimezones(data) {
+        const date = data.date;
+        const onlyShowDate = data.onlyShowDate;
+        const timezones = data.timezones;
+        return this.getDateAsFormattedArrayInMultipleTimezones({
+            date,
+            onlyShowDate,
+            timezones,
+        }).join("<br/>");
+    }
+    static getDateAsFormattedStringInMultipleTimezones(data) {
+        const date = data.date;
+        const onlyShowDate = data.onlyShowDate;
+        const timezones = data.timezones;
+        return this.getDateAsFormattedArrayInMultipleTimezones({
+            date,
+            onlyShowDate,
+            timezones,
+        }).join("\n");
     }
     static getDateAsLocalFormattedString(date, onlyShowDate) {
         date = this.fromString(date);
-        let formatstring = 'MMM DD YYYY, HH:mm';
+        let formatstring = "MMM DD YYYY, HH:mm";
         if (onlyShowDate) {
-            formatstring = 'MMM DD, YYYY';
+            formatstring = "MMM DD, YYYY";
         }
         const momentDate = moment(date).local();
         return (momentDate.format(formatstring) +
-            ' ' +
-            (onlyShowDate ? '' : this.getCurrentTimezoneString())).trim();
+            " " +
+            (onlyShowDate ? "" : this.getCurrentTimezoneString())).trim();
     }
     static getDayInSeconds(days) {
         if (!days) {
@@ -658,7 +699,17 @@ export default class OneUptimeDate {
         return 24 * 60 * 60 * days;
     }
     static getCurrentTimezoneString() {
-        return moment.tz(moment.tz.guess()).zoneAbbr();
+        return this.getZoneAbbrByTimezone(this.getCurrentTimezone());
+    }
+    static getZoneAbbrByTimezone(timezone) {
+        let zoneAbbr = moment.tz(timezone).zoneAbbr();
+        if (zoneAbbr.startsWith("+") || zoneAbbr.startsWith("-")) {
+            zoneAbbr = "GMT" + zoneAbbr;
+        }
+        return zoneAbbr;
+    }
+    static getCurrentTimezone() {
+        return moment.tz.guess();
     }
     static getDateString(date) {
         date = this.fromString(date);
@@ -676,21 +727,21 @@ export default class OneUptimeDate {
         if (date instanceof Date) {
             return date;
         }
-        if (typeof date === 'string') {
+        if (typeof date === "string") {
             return moment(date).toDate();
         }
         if (date &&
-            date['value'] &&
-            typeof date['value'] === 'string' &&
-            date['_type'] &&
-            (date['_type'] === 'Date' || date['_type'] === 'DateTime')) {
-            return moment(date['value']).toDate();
+            date["value"] &&
+            typeof date["value"] === "string" &&
+            date["_type"] &&
+            (date["_type"] === "Date" || date["_type"] === "DateTime")) {
+            return moment(date["value"]).toDate();
         }
-        throw new BadDataException('Invalid date');
+        throw new BadDataException("Invalid date: " + date.toString());
     }
     static asDateForDatabaseQuery(date) {
         date = this.fromString(date);
-        const formatstring = 'YYYY-MM-DD';
+        const formatstring = "YYYY-MM-DD";
         return moment(date).local().format(formatstring);
     }
     static asFilterDateForDatabaseQuery(date) {
@@ -704,15 +755,15 @@ export default class OneUptimeDate {
         const seconds = data.seconds;
         //validate the hour
         if (hour < 0 || hour > 23) {
-            throw new BadDataException('Invalid hour');
+            throw new BadDataException("Invalid hour");
         }
         //validate the minutes
         if (minutes < 0 || minutes > 59) {
-            throw new BadDataException('Invalid minutes');
+            throw new BadDataException("Invalid minutes");
         }
         //validate the seconds
         if (seconds < 0 || seconds > 59) {
-            throw new BadDataException('Invalid seconds');
+            throw new BadDataException("Invalid seconds");
         }
         const date = OneUptimeDate.getCurrentDate();
         date.setHours(hour);
@@ -722,7 +773,7 @@ export default class OneUptimeDate {
     }
     static toDatabaseDate(date) {
         date = this.fromString(date);
-        return moment(date).format('YYYY-MM-DD HH:mm:ss');
+        return moment(date).format("YYYY-MM-DD HH:mm:ss");
     }
 }
 //# sourceMappingURL=Date.js.map