@oneuptime/common 1.0.0

package/build/dist/Types/Date.js

@@ -0,0 +1,698 @@
+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';
+export const Moment = moment;
+export default class OneUptimeDate {
+    getNanoSecondsFromSeconds(seconds) {
+        return seconds * 1000 * 1000 * 1000;
+    }
+    getMicroSecondsFromSeconds(seconds) {
+        return seconds * 1000 * 1000;
+    }
+    getMilliSecondsFromSeconds(seconds) {
+        return seconds * 1000;
+    }
+    static getCurrentDateAsUnixNano() {
+        return this.toUnixNano(this.getCurrentDate());
+    }
+    static toUnixNano(date) {
+        return date.getTime() * 1000000;
+    }
+    static getMillisecondsBetweenTwoUnixNanoDates(startDate, endDate) {
+        return endDate - startDate;
+    }
+    static moveDateToTheDayOfWeek(date, moveToWeek, dayOfWeek) {
+        // date will be moved to the week of "moveToWeek" and then to the day of week "dayOfWeek"
+        date = this.fromString(date);
+        date = this.keepTimeButMoveDay(date, moveToWeek);
+        // now move the date to the day of week
+        const dateDayOfWeek = this.getDayOfWeek(date);
+        if (dateDayOfWeek === dayOfWeek) {
+            return date;
+        }
+        const numberOfDayOfWeek = DayOfWeekUtil.getNumberOfDayOfWeek(dayOfWeek);
+        const dateDayOfWeekNumber = DayOfWeekUtil.getNumberOfDayOfWeek(dateDayOfWeek);
+        const difference = numberOfDayOfWeek - dateDayOfWeekNumber;
+        if (difference === 0) {
+            return date;
+        }
+        return this.addRemoveDays(date, difference);
+    }
+    static isOverlapping(start, end, start1, end1) {
+        start = this.fromString(start);
+        end = this.fromString(end);
+        start1 = this.fromString(start1);
+        end1 = this.fromString(end1);
+        let isOverlapping = moment(start).isBetween(start1, end1) ||
+            moment(end).isBetween(start1, end1) ||
+            moment(start).isSame(start1) ||
+            moment(end).isSame(end1);
+        if (!isOverlapping) {
+            // check if the start1 and end1 are in between start and end
+            isOverlapping =
+                moment(start1).isBetween(start, end) ||
+                    moment(end1).isBetween(start, end) ||
+                    moment(start1).isSame(start) ||
+                    moment(end1).isSame(end);
+        }
+        return isOverlapping;
+    }
+    static getCurrentDate() {
+        return moment().toDate();
+    }
+    static fromNow(date) {
+        return moment(date).fromNow();
+    }
+    static differenceBetweenTwoDatesAsFromattedString(date1, date2) {
+        const seconds = this.getSecondsBetweenTwoDates(date1, date2);
+        return this.secondsToFormattedFriendlyTimeString(seconds);
+    }
+    static toTimeString(date) {
+        if (typeof date === 'string') {
+            date = this.fromString(date);
+        }
+        return moment(date).format('HH:mm');
+    }
+    static isSame(date1, date2) {
+        date1 = this.fromString(date1);
+        date2 = this.fromString(date2);
+        return moment(date1).isSame(date2);
+    }
+    static getDaysBetweenTwoDates(startDate, endDate) {
+        startDate = this.fromString(startDate);
+        endDate = this.fromString(endDate);
+        return moment(endDate).diff(moment(startDate), 'days');
+    }
+    static getDaysBetweenTwoDatesInclusive(startDate, endDate) {
+        return this.getDaysBetweenTwoDates(startDate, endDate) + 1;
+    }
+    static getHoursBetweenTwoDates(startDate, endDate) {
+        startDate = this.fromString(startDate);
+        endDate = this.fromString(endDate);
+        return moment(endDate).diff(moment(startDate), 'hours');
+    }
+    static getHoursBetweenTwoDatesInclusive(startDate, endDate) {
+        return this.getHoursBetweenTwoDates(startDate, endDate) + 1;
+    }
+    static getMinutesBetweenTwoDates(startDate, endDate) {
+        startDate = this.fromString(startDate);
+        endDate = this.fromString(endDate);
+        return moment(endDate).diff(moment(startDate), 'minutes');
+    }
+    static getMinutesBetweenTwoDatesInclusive(startDate, endDate) {
+        return this.getMinutesBetweenTwoDates(startDate, endDate) + 1;
+    }
+    static getSecondsBetweenTwoDates(startDate, endDate) {
+        startDate = this.fromString(startDate);
+        endDate = this.fromString(endDate);
+        return moment(endDate).diff(moment(startDate), 'seconds');
+    }
+    static getSecondsBetweenTwoDatesInclusive(startDate, endDate) {
+        return this.getSecondsBetweenTwoDates(startDate, endDate) + 1;
+    }
+    static getWeeksBetweenTwoDates(startDate, endDate) {
+        startDate = this.fromString(startDate);
+        endDate = this.fromString(endDate);
+        return moment(endDate).diff(moment(startDate), 'weeks');
+    }
+    static getWeeksBetweenTwoDatesInclusive(startDate, endDate) {
+        return this.getWeeksBetweenTwoDates(startDate, endDate) + 1;
+    }
+    static getMonthsBetweenTwoDates(startDate, endDate) {
+        startDate = this.fromString(startDate);
+        endDate = this.fromString(endDate);
+        return moment(endDate).diff(moment(startDate), 'months');
+    }
+    static getMonthsBetweenTwoDatesInclusive(startDate, endDate) {
+        return this.getMonthsBetweenTwoDates(startDate, endDate) + 1;
+    }
+    static getYearsBetweenTwoDates(startDate, endDate) {
+        startDate = this.fromString(startDate);
+        endDate = this.fromString(endDate);
+        return moment(endDate).diff(moment(startDate), 'years');
+    }
+    static getYearsBetweenTwoDatesInclusive(startDate, endDate) {
+        return this.getYearsBetweenTwoDates(startDate, endDate) + 1;
+    }
+    static toString(date) {
+        if (!date) {
+            return '';
+        }
+        date = this.fromString(date);
+        return date.toISOString();
+    }
+    static getCurrentMomentDate() {
+        return moment();
+    }
+    static keepTimeButMoveDay(keepTimeFor, moveDayTo) {
+        keepTimeFor = this.fromString(keepTimeFor);
+        moveDayTo = this.fromString(moveDayTo);
+        return moment(moveDayTo)
+            .set({
+            hour: keepTimeFor.getHours(),
+            minute: keepTimeFor.getMinutes(),
+            second: keepTimeFor.getSeconds(),
+            millisecond: keepTimeFor.getMilliseconds(),
+        })
+            .toDate();
+    }
+    static getOneMinAgo() {
+        return this.getSomeMinutesAgo(new PositiveNumber(1));
+    }
+    static getOneDayAgo() {
+        return this.getSomeDaysAgo(new PositiveNumber(1));
+    }
+    static fromUnixNano(timestamp) {
+        return moment(timestamp / 1000000).toDate();
+    }
+    static getSecondsTo(date) {
+        date = this.fromString(date);
+        const dif = date.getTime() - this.getCurrentDate().getTime();
+        const Seconds_from_T1_to_T2 = dif / 1000;
+        return Math.abs(Seconds_from_T1_to_T2);
+    }
+    static getSomeMinutesAgo(minutes) {
+        if (!(minutes instanceof PositiveNumber)) {
+            minutes = new PositiveNumber(minutes);
+        }
+        return this.getCurrentMomentDate()
+            .add(-1 * minutes.toNumber(), 'minutes')
+            .toDate();
+    }
+    static timezoneOffsetDate(date) {
+        date = this.fromString(date);
+        return this.addRemoveMinutes(date, date.getTimezoneOffset());
+    }
+    static toDateTimeLocalString(date) {
+        date = this.fromString(date);
+        const ten = (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;
+    }
+    static fromJSON(json) {
+        if (json['_type'] === ObjectType.DateTime) {
+            return OneUptimeDate.fromString(json['value']);
+        }
+        throw new BadDataException('Invalid JSON: ' + JSON.stringify(json));
+    }
+    static toJSON(date) {
+        return {
+            _type: ObjectType.DateTime,
+            value: OneUptimeDate.toString(date),
+        };
+    }
+    static areOnTheSameDay(date1, date2) {
+        date1 = this.fromString(date1);
+        date2 = this.fromString(date2);
+        return moment(date1).isSame(date2, 'day');
+    }
+    static areOnTheSameMonth(date1, date2) {
+        date1 = this.fromString(date1);
+        date2 = this.fromString(date2);
+        return moment(date1).isSame(date2, 'month');
+    }
+    static areOnTheSameYear(date1, date2) {
+        date1 = this.fromString(date1);
+        date2 = this.fromString(date2);
+        return moment(date1).isSame(date2, 'year');
+    }
+    static areOnTheSameHour(date1, date2) {
+        date1 = this.fromString(date1);
+        date2 = this.fromString(date2);
+        return moment(date1).isSame(date2, 'hour');
+    }
+    static areOnTheSameMinute(date1, date2) {
+        date1 = this.fromString(date1);
+        date2 = this.fromString(date2);
+        return moment(date1).isSame(date2, 'minute');
+    }
+    static areOnTheSameSecond(date1, date2) {
+        date1 = this.fromString(date1);
+        date2 = this.fromString(date2);
+        return moment(date1).isSame(date2, 'second');
+    }
+    static areOnTheSameWeek(date1, date2) {
+        date1 = this.fromString(date1);
+        date2 = this.fromString(date2);
+        return moment(date1).isSame(date2, 'week');
+    }
+    static addRemoveMinutes(date, minutes) {
+        date = this.fromString(date);
+        return moment(date).add(minutes, 'minutes').toDate();
+    }
+    static addRemoveDays(date, days) {
+        date = this.fromString(date);
+        return moment(date).add(days, 'days').toDate();
+    }
+    static addRemoveHours(date, hours) {
+        date = this.fromString(date);
+        return moment(date).add(hours, 'hours').toDate();
+    }
+    static addRemoveYears(date, years) {
+        date = this.fromString(date);
+        return moment(date).add(years, 'years').toDate();
+    }
+    static addRemoveMonths(date, months) {
+        date = this.fromString(date);
+        return moment(date).add(months, 'months').toDate();
+    }
+    static addRemoveWeeks(date, weeks) {
+        date = this.fromString(date);
+        return moment(date).add(weeks, 'weeks').toDate();
+    }
+    static addRemoveSeconds(date, seconds) {
+        date = this.fromString(date);
+        return moment(date).add(seconds, 'seconds').toDate();
+    }
+    static getSecondsInDays(days) {
+        if (!(days instanceof PositiveNumber)) {
+            days = new PositiveNumber(days);
+        }
+        return days.positiveNumber * 24 * 60 * 60;
+    }
+    static getMillisecondsInDays(days) {
+        return this.getSecondsInDays(days) * 1000;
+    }
+    static getSomeHoursAgo(hours) {
+        if (!(hours instanceof PositiveNumber)) {
+            hours = new PositiveNumber(hours);
+        }
+        return this.getCurrentMomentDate()
+            .add(-1 * hours.toNumber(), 'hours')
+            .toDate();
+    }
+    static getSomeDaysAgo(days) {
+        if (!(days instanceof PositiveNumber)) {
+            days = new PositiveNumber(days);
+        }
+        return this.getCurrentMomentDate()
+            .add(-1 * days.toNumber(), 'days')
+            .toDate();
+    }
+    static getSomeDaysAgoFromDate(date, days) {
+        date = this.fromString(date);
+        if (!(days instanceof PositiveNumber)) {
+            days = new PositiveNumber(days);
+        }
+        return moment(date)
+            .add(-1 * days.toNumber(), 'days')
+            .toDate();
+    }
+    static getSomeDaysAfterFromDate(date, days) {
+        date = this.fromString(date);
+        if (!(days instanceof PositiveNumber)) {
+            days = new PositiveNumber(days);
+        }
+        return moment(date).add(Number(days.toNumber()), 'days').toDate();
+    }
+    static getSomeDaysBeforeFromDate(date, days) {
+        date = this.fromString(date);
+        if (!(days instanceof PositiveNumber)) {
+            days = new PositiveNumber(days);
+        }
+        return moment(date)
+            .add(-1 * Number(days.toNumber()), 'days')
+            .toDate();
+    }
+    static getSomeSecondsAgo(seconds) {
+        if (!(seconds instanceof PositiveNumber)) {
+            seconds = new PositiveNumber(seconds);
+        }
+        return this.getCurrentMomentDate()
+            .add(-1 * seconds.toNumber(), 'seconds')
+            .toDate();
+    }
+    static getOneMinAfter() {
+        return this.getSomeMinutesAfter(new PositiveNumber(1));
+    }
+    static getOneDayAfter() {
+        return this.getSomeDaysAfter(new PositiveNumber(1));
+    }
+    static getSomeMinutesAfter(minutes) {
+        if (!(minutes instanceof PositiveNumber)) {
+            minutes = new PositiveNumber(minutes);
+        }
+        return this.getCurrentMomentDate()
+            .add(minutes.toNumber(), 'minutes')
+            .toDate();
+    }
+    static getSomeHoursAfter(hours) {
+        if (!(hours instanceof PositiveNumber)) {
+            hours = new PositiveNumber(hours);
+        }
+        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();
+    }
+    static secondsToFormattedTimeString(seconds) {
+        return moment.utc(seconds * 1000).format('HH:mm:ss');
+    }
+    static toUnixTimestamp(date) {
+        return Math.floor(date.getTime() / 1000);
+    }
+    static secondsToFormattedFriendlyTimeString(seconds) {
+        const startDate = moment.utc(0);
+        const date = moment.utc(seconds * 1000);
+        // get the difference between the two dates as friendly formatted string
+        let formattedString = '';
+        // years between two dates
+        const years = date.diff(startDate, 'years');
+        if (years > 0) {
+            let text = 'years ';
+            if (years === 1) {
+                text = 'year ';
+            }
+            // add years to start date
+            startDate.add(years, 'years');
+            formattedString += years + ' ' + text;
+        }
+        const months = date.diff(startDate, 'months');
+        if (months > 0) {
+            let text = 'months ';
+            if (months === 1) {
+                text = 'month ';
+            }
+            // add months to start date
+            startDate.add(months, 'months');
+            formattedString += months + ' ' + text;
+        }
+        const days = date.diff(startDate, 'days');
+        if (days > 0) {
+            let text = 'days ';
+            if (days === 1) {
+                text = 'day ';
+            }
+            // add days to start date
+            startDate.add(days, 'days');
+            formattedString += days + ' ' + text;
+        }
+        const hours = date.diff(startDate, 'hours');
+        if (hours > 0) {
+            let text = 'hours ';
+            if (hours === 1) {
+                text = 'hour ';
+            }
+            // add hours to start date
+            startDate.add(hours, 'hours');
+            formattedString += hours + ' ' + text;
+        }
+        const minutes = date.diff(startDate, 'minutes');
+        if (minutes > 0) {
+            let text = 'mins ';
+            if (minutes === 1) {
+                text = 'min ';
+            }
+            // add minutes to start date
+            startDate.add(minutes, 'minutes');
+            formattedString += minutes + ' ' + text;
+        }
+        const secondsLeft = date.diff(startDate, 'seconds');
+        if (secondsLeft > 0) {
+            let text = 'secs ';
+            if (secondsLeft === 1) {
+                text = 'sec ';
+            }
+            // add seconds to start date
+            startDate.add(secondsLeft, 'seconds');
+            formattedString += secondsLeft + ' ' + text;
+        }
+        return formattedString.trim();
+    }
+    static getGreaterDate(a, b) {
+        a = this.fromString(a);
+        b = this.fromString(b);
+        if (this.isAfter(a, b)) {
+            return a;
+        }
+        return b;
+    }
+    static getLesserDate(a, b) {
+        a = this.fromString(a);
+        b = this.fromString(b);
+        if (this.isBefore(a, b)) {
+            return a;
+        }
+        return b;
+    }
+    static getSecondsBetweenDates(start, end) {
+        start = this.fromString(start);
+        end = this.fromString(end);
+        const duration = moment.duration(moment(end).diff(moment(start)));
+        return duration.asSeconds();
+    }
+    static getSomeDaysAfterDate(date, days) {
+        if (!(days instanceof PositiveNumber)) {
+            days = new PositiveNumber(days);
+        }
+        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')
+            .toDate();
+    }
+    static getNumberOfDaysBetweenDates(startDate, endDate) {
+        const a = moment(startDate);
+        const b = moment(endDate);
+        return b.diff(a, 'days');
+    }
+    static getNumberOfMinutesBetweenDates(startDate, endDate) {
+        const a = moment(startDate);
+        const b = moment(endDate);
+        return b.diff(a, 'minutes');
+    }
+    static getNumberOfDaysBetweenDatesInclusive(startDate, endDate) {
+        return this.getNumberOfDaysBetweenDates(startDate, endDate) + 1;
+    }
+    static momentToDate(moment) {
+        return moment.toDate();
+    }
+    static getCurrentYear() {
+        return moment().year();
+    }
+    static getStartOfDay(date) {
+        date = this.fromString(date);
+        return moment(date).startOf('day').toDate();
+    }
+    static getEndOfDay(date) {
+        date = this.fromString(date);
+        return moment(date).endOf('day').toDate();
+    }
+    static isBetween(date, startDate, endDate) {
+        date = this.fromString(date);
+        startDate = this.fromString(startDate);
+        endDate = this.fromString(endDate);
+        return moment(date).isBetween(startDate, endDate);
+    }
+    static isAfter(date, startDate) {
+        date = this.fromString(date);
+        startDate = this.fromString(startDate);
+        return moment(date).isAfter(startDate);
+    }
+    static isOnOrAfter(date, startDate) {
+        date = this.fromString(date);
+        startDate = this.fromString(startDate);
+        return moment(date).isSameOrAfter(startDate);
+    }
+    static getDayOfWeek(date) {
+        const dayOfWeek = this.geyDayOfWeekAsNumber(date);
+        if (dayOfWeek === 1) {
+            return DayOfWeek.Monday;
+        }
+        else if (dayOfWeek === 2) {
+            return DayOfWeek.Tuesday;
+        }
+        else if (dayOfWeek === 3) {
+            return DayOfWeek.Wednesday;
+        }
+        else if (dayOfWeek === 4) {
+            return DayOfWeek.Thursday;
+        }
+        else if (dayOfWeek === 5) {
+            return DayOfWeek.Friday;
+        }
+        else if (dayOfWeek === 6) {
+            return DayOfWeek.Saturday;
+        }
+        else if (dayOfWeek === 7) {
+            return DayOfWeek.Sunday;
+        }
+        throw new BadDataException('Invalid day of week');
+    }
+    static geyDayOfWeekAsNumber(date) {
+        date = this.fromString(date);
+        return moment(date).isoWeekday();
+    }
+    static isOnOrBefore(date, endDate) {
+        date = this.fromString(date);
+        endDate = this.fromString(endDate);
+        return moment(date).isSameOrBefore(endDate);
+    }
+    static isEqualBySeconds(date, startDate) {
+        date = this.fromString(date);
+        startDate = this.fromString(startDate);
+        return moment(date).isSame(startDate, 'seconds');
+    }
+    static hasExpired(expirationDate) {
+        expirationDate = this.fromString(expirationDate);
+        return !moment(this.getCurrentDate()).isBefore(expirationDate);
+    }
+    static isBefore(date, endDate) {
+        date = this.fromString(date);
+        endDate = this.fromString(endDate);
+        return moment(date).isBefore(endDate);
+    }
+    static getCurrentDateAsFormattedString() {
+        return this.getDateAsFormattedString(new Date());
+    }
+    static getDateAsFormattedString(date, onlyShowDate) {
+        date = this.fromString(date);
+        let formatstring = 'MMM DD YYYY, HH:mm';
+        if (onlyShowDate) {
+            formatstring = 'MMM DD, YYYY';
+        }
+        return (moment(date).format(formatstring) +
+            ' ' +
+            (onlyShowDate ? '' : this.getCurrentTimezoneString()));
+    }
+    static getDifferenceInMinutes(date, date2) {
+        date = this.fromString(date);
+        date2 = this.fromString(date2);
+        const minutes = moment(date).diff(moment(date2), 'minutes');
+        if (minutes < 0) {
+            return minutes * -1;
+        }
+        return minutes;
+    }
+    static getDateAsFormattedArrayInMultipleTimezones(date, onlyShowDate) {
+        date = this.fromString(date);
+        let formatstring = 'MMM DD YYYY, HH:mm';
+        if (onlyShowDate) {
+            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'));
+        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 getDateAsLocalFormattedString(date, onlyShowDate) {
+        date = this.fromString(date);
+        let formatstring = 'MMM DD YYYY, HH:mm';
+        if (onlyShowDate) {
+            formatstring = 'MMM DD, YYYY';
+        }
+        const momentDate = moment(date).local();
+        return (momentDate.format(formatstring) +
+            ' ' +
+            (onlyShowDate ? '' : this.getCurrentTimezoneString())).trim();
+    }
+    static getDayInSeconds(days) {
+        if (!days) {
+            days = 1;
+        }
+        return 24 * 60 * 60 * days;
+    }
+    static getCurrentTimezoneString() {
+        return moment.tz(moment.tz.guess()).zoneAbbr();
+    }
+    static getDateString(date) {
+        date = this.fromString(date);
+        return this.getDateAsLocalFormattedString(date, true);
+    }
+    static isInThePast(date) {
+        date = this.fromString(date);
+        return moment(date).isBefore(new Date());
+    }
+    static isInTheFuture(date) {
+        date = this.fromString(date);
+        return moment(date).isAfter(new Date());
+    }
+    static fromString(date) {
+        if (date instanceof Date) {
+            return date;
+        }
+        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();
+        }
+        throw new BadDataException('Invalid date');
+    }
+    static asDateForDatabaseQuery(date) {
+        date = this.fromString(date);
+        const formatstring = 'YYYY-MM-DD';
+        return moment(date).local().format(formatstring);
+    }
+    static asFilterDateForDatabaseQuery(date) {
+        date = this.fromString(date);
+        const formattedDate = moment(date).toDate();
+        return new InBetween(OneUptimeDate.getStartOfDay(formattedDate), OneUptimeDate.getEndOfDay(formattedDate));
+    }
+    static getDateWithCustomTime(data) {
+        const hour = data.hours;
+        const minutes = data.minutes;
+        const seconds = data.seconds;
+        //validate the hour
+        if (hour < 0 || hour > 23) {
+            throw new BadDataException('Invalid hour');
+        }
+        //validate the minutes
+        if (minutes < 0 || minutes > 59) {
+            throw new BadDataException('Invalid minutes');
+        }
+        //validate the seconds
+        if (seconds < 0 || seconds > 59) {
+            throw new BadDataException('Invalid seconds');
+        }
+        const date = OneUptimeDate.getCurrentDate();
+        date.setHours(hour);
+        date.setMinutes(minutes);
+        date.setSeconds(seconds);
+        return date;
+    }
+    static toDatabaseDate(date) {
+        date = this.fromString(date);
+        return moment(date).format('YYYY-MM-DD HH:mm:ss');
+    }
+}
+//# sourceMappingURL=Date.js.map