diff --git a/ui-ngx/src/app/core/api/data-aggregator.ts b/ui-ngx/src/app/core/api/data-aggregator.ts
index 2c27e6fcf0..02c1c8649a 100644
--- a/ui-ngx/src/app/core/api/data-aggregator.ts
+++ b/ui-ngx/src/app/core/api/data-aggregator.ts
@@ -17,10 +17,9 @@
 import { SubscriptionData, SubscriptionDataHolder } from '@app/shared/models/telemetry/telemetry.models';
 import {
   AggregationType, calculateIntervalComparisonEndTime,
-  calculateIntervalEndTime,
-  calculateIntervalStartTime,
+  calculateIntervalEndTime, calculateIntervalStartEndTime,
   getCurrentTime,
-  getCurrentTimeForComparison,
+  getCurrentTimeForComparison, getTime,
   SubscriptionTimewindow
 } from '@shared/models/time/time.models';
 import { UtilsService } from '@core/services/utils.service';
@@ -245,11 +244,12 @@ export class DataAggregator {
     this.startTs = this.subsTw.startTs + this.subsTw.tsOffset;
     if (this.subsTw.quickInterval) {
       if (this.subsTw.timeForComparison === 'previousInterval') {
+        const startDate = getTime(this.subsTw.startTs, this.subsTw.timezone);
         const currentDate = getCurrentTime(this.subsTw.timezone);
-        this.endTs = calculateIntervalComparisonEndTime(this.subsTw.quickInterval, currentDate) + this.subsTw.tsOffset;
+        this.endTs = calculateIntervalComparisonEndTime(this.subsTw.quickInterval, startDate, currentDate) + this.subsTw.tsOffset;
       } else {
-        const currentDate = this.getCurrentTime();
-        this.endTs = calculateIntervalEndTime(this.subsTw.quickInterval, currentDate) + this.subsTw.tsOffset;
+        const startDate = getTime(this.subsTw.startTs, this.subsTw.timezone);
+        this.endTs = calculateIntervalEndTime(this.subsTw.quickInterval, startDate, this.subsTw.timezone) + this.subsTw.tsOffset;
       }
     } else {
       this.endTs = this.startTs + this.subsTw.aggregation.timeWindow;
@@ -270,9 +270,9 @@ export class DataAggregator {
       if (delta || !this.data || rangeChanged) {
         const tickTs = delta * this.subsTw.aggregation.interval;
         if (this.subsTw.quickInterval) {
-          const currentDate = this.getCurrentTime();
-          this.startTs = calculateIntervalStartTime(this.subsTw.quickInterval, currentDate) + this.subsTw.tsOffset;
-          this.endTs = calculateIntervalEndTime(this.subsTw.quickInterval, currentDate) + this.subsTw.tsOffset;
+          const startEndTime = calculateIntervalStartEndTime(this.subsTw.quickInterval, this.subsTw.timezone);
+          this.startTs = startEndTime[0] + this.subsTw.tsOffset;
+          this.endTs = startEndTime[1] + this.subsTw.tsOffset;
         } else {
           this.startTs += tickTs;
           this.endTs += tickTs;
diff --git a/ui-ngx/src/app/core/api/widget-subscription.ts b/ui-ngx/src/app/core/api/widget-subscription.ts
index 6663735bd5..b74a807729 100644
--- a/ui-ngx/src/app/core/api/widget-subscription.ts
+++ b/ui-ngx/src/app/core/api/widget-subscription.ts
@@ -37,12 +37,11 @@ import {
 } from '@app/shared/models/widget.models';
 import { HttpErrorResponse } from '@angular/common/http';
 import {
-  calculateIntervalEndTime,
-  calculateIntervalStartTime,
+  calculateIntervalStartEndTime,
   calculateTsOffset, ComparisonDuration,
   createSubscriptionTimewindow,
   createTimewindowForComparison,
-  getCurrentTime, isHistoryTypeTimewindow,
+  isHistoryTypeTimewindow,
   SubscriptionTimewindow,
   Timewindow, timewindowTypeChanged,
   toHistoryTimewindow,
@@ -1106,11 +1105,9 @@ export class WidgetSubscription implements IWidgetSubscription {
     this.timeWindow.timezone = this.subscriptionTimewindow.timezone;
     if (this.subscriptionTimewindow.realtimeWindowMs) {
       if (this.subscriptionTimewindow.quickInterval) {
-        const currentDate = getCurrentTime(this.subscriptionTimewindow.timezone);
-        this.timeWindow.maxTime = calculateIntervalEndTime(
-          this.subscriptionTimewindow.quickInterval, currentDate) + this.subscriptionTimewindow.tsOffset;
-        this.timeWindow.minTime = calculateIntervalStartTime(
-          this.subscriptionTimewindow.quickInterval, currentDate) + this.subscriptionTimewindow.tsOffset;
+        const startEndTime = calculateIntervalStartEndTime(this.subscriptionTimewindow.quickInterval, this.subscriptionTimewindow.timezone);
+        this.timeWindow.maxTime = startEndTime[1] + this.subscriptionTimewindow.tsOffset;
+        this.timeWindow.minTime = startEndTime[0] + this.subscriptionTimewindow.tsOffset;
       } else {
         this.timeWindow.maxTime = moment().valueOf() + this.subscriptionTimewindow.tsOffset + this.timeWindow.stDiff;
         this.timeWindow.minTime = this.timeWindow.maxTime - this.subscriptionTimewindow.realtimeWindowMs;
diff --git a/ui-ngx/src/app/modules/home/components/entity/entities-table.component.ts b/ui-ngx/src/app/modules/home/components/entity/entities-table.component.ts
index c1dd69ecf5..40a6b0cece 100644
--- a/ui-ngx/src/app/modules/home/components/entity/entities-table.component.ts
+++ b/ui-ngx/src/app/modules/home/components/entity/entities-table.component.ts
@@ -56,9 +56,7 @@ import { DialogService } from '@core/services/dialog.service';
 import { AddEntityDialogComponent } from './add-entity-dialog.component';
 import { AddEntityDialogData, EntityAction } from '@home/models/entity/entity-component.models';
 import {
-  calculateIntervalEndTime,
-  calculateIntervalStartTime,
-  getCurrentTime,
+  calculateIntervalStartEndTime,
   HistoryWindowType,
   Timewindow
 } from '@shared/models/time/time.models';
@@ -303,9 +301,9 @@ export class EntitiesTableComponent extends PageComponent implements AfterViewIn
         timePageLink.startTime = currentTime - this.timewindow.history.timewindowMs;
         timePageLink.endTime = currentTime;
       } else if (this.timewindow.history.historyType === HistoryWindowType.INTERVAL) {
-        const currentDate = getCurrentTime();
-        timePageLink.startTime = calculateIntervalStartTime(this.timewindow.history.quickInterval, currentDate);
-        timePageLink.endTime = calculateIntervalEndTime(this.timewindow.history.quickInterval, currentDate);
+        const startEndTime = calculateIntervalStartEndTime(this.timewindow.history.quickInterval);
+        timePageLink.startTime = startEndTime[0];
+        timePageLink.endTime = startEndTime[1];
       } else {
         timePageLink.startTime = this.timewindow.history.fixedTimewindow.startTimeMs;
         timePageLink.endTime = this.timewindow.history.fixedTimewindow.endTimeMs;
diff --git a/ui-ngx/src/app/shared/models/time/time.models.ts b/ui-ngx/src/app/shared/models/time/time.models.ts
index a686857ed1..c9520f09df 100644
--- a/ui-ngx/src/app/shared/models/time/time.models.ts
+++ b/ui-ngx/src/app/shared/models/time/time.models.ts
@@ -174,19 +174,18 @@ export const QuickTimeIntervalTranslationMap = new Map<QuickTimeInterval, string
 ]);
 
 export function historyInterval(timewindowMs: number): Timewindow {
-  const timewindow: Timewindow = {
+  return {
     selectedTab: TimewindowType.HISTORY,
     history: {
       historyType: HistoryWindowType.LAST_INTERVAL,
       timewindowMs
     }
   };
-  return timewindow;
 }
 
 export function defaultTimewindow(timeService: TimeService): Timewindow {
   const currentTime = moment().valueOf();
-  const timewindow: Timewindow = {
+  return {
     displayValue: '',
     hideInterval: false,
     hideAggregation: false,
@@ -214,7 +213,6 @@ export function defaultTimewindow(timeService: TimeService): Timewindow {
       limit: Math.floor(timeService.getMaxDatapointsLimit() / 2)
     }
   };
-  return timewindow;
 }
 
 function getTimewindowType(timewindow: Timewindow): TimewindowType {
@@ -304,7 +302,7 @@ export function toHistoryTimewindow(timewindow: Timewindow, startTimeMs: number,
     aggType = AggregationType.AVG;
     limit = timeService.getMaxDatapointsLimit();
   }
-  const historyTimewindow: Timewindow = {
+  return {
     hideInterval: timewindow.hideInterval || false,
     hideAggregation: timewindow.hideAggregation || false,
     hideAggInterval: timewindow.hideAggInterval || false,
@@ -324,7 +322,6 @@ export function toHistoryTimewindow(timewindow: Timewindow, startTimeMs: number,
     },
     timezone: timewindow.timezone
   };
-  return historyTimewindow;
 }
 
 export function timewindowTypeChanged(newTimewindow: Timewindow, oldTimewindow: Timewindow): boolean {
@@ -363,7 +360,7 @@ export function createSubscriptionTimewindow(timewindow: Timewindow, stDiff: num
     timezone: timewindow.timezone,
     tsOffset: calculateTsOffset(timewindow.timezone)
   };
-  let aggTimewindow = 0;
+  let aggTimewindow;
   if (stateData) {
     subscriptionTimewindow.aggregation.type = AggregationType.NONE;
     subscriptionTimewindow.aggregation.stateData = true;
@@ -385,14 +382,15 @@ export function createSubscriptionTimewindow(timewindow: Timewindow, stDiff: num
       }
     }
     if (realtimeType === RealtimeWindowType.INTERVAL) {
-      const currentDate = getCurrentTime(timewindow.timezone);
       subscriptionTimewindow.realtimeWindowMs =
-        getSubscriptionRealtimeWindowFromTimeInterval(timewindow.realtime.quickInterval, currentDate);
+        getSubscriptionRealtimeWindowFromTimeInterval(timewindow.realtime.quickInterval, timewindow.timezone);
       subscriptionTimewindow.quickInterval = timewindow.realtime.quickInterval;
-      subscriptionTimewindow.startTs = calculateIntervalStartTime(timewindow.realtime.quickInterval, currentDate);
+      const currentDate = getCurrentTime(timewindow.timezone);
+      subscriptionTimewindow.startTs = calculateIntervalStartTime(timewindow.realtime.quickInterval, currentDate).valueOf();
     } else {
       subscriptionTimewindow.realtimeWindowMs = timewindow.realtime.timewindowMs;
-      subscriptionTimewindow.startTs = Date.now() + stDiff - subscriptionTimewindow.realtimeWindowMs;
+      const currentDate = getCurrentTime(timewindow.timezone);
+      subscriptionTimewindow.startTs = currentDate.valueOf() + stDiff - subscriptionTimewindow.realtimeWindowMs;
     }
     subscriptionTimewindow.aggregation.interval =
       timeService.boundIntervalToTimewindow(subscriptionTimewindow.realtimeWindowMs, timewindow.realtime.interval,
@@ -425,10 +423,10 @@ export function createSubscriptionTimewindow(timewindow: Timewindow, stDiff: num
       };
       aggTimewindow = timewindow.history.timewindowMs;
     } else if (historyType === HistoryWindowType.INTERVAL) {
-      const currentDate = getCurrentTime(timewindow.timezone);
+      const startEndTime = calculateIntervalStartEndTime(timewindow.history.quickInterval, timewindow.timezone);
       subscriptionTimewindow.fixedWindow = {
-        startTimeMs: calculateIntervalStartTime(timewindow.history.quickInterval, currentDate),
-        endTimeMs: calculateIntervalEndTime(timewindow.history.quickInterval, currentDate)
+        startTimeMs: startEndTime[0],
+        endTimeMs: startEndTime[1]
       };
       aggTimewindow = subscriptionTimewindow.fixedWindow.endTimeMs - subscriptionTimewindow.fixedWindow.startTimeMs;
       subscriptionTimewindow.quickInterval = timewindow.history.quickInterval;
@@ -451,7 +449,8 @@ export function createSubscriptionTimewindow(timewindow: Timewindow, stDiff: num
   return subscriptionTimewindow;
 }
 
-function getSubscriptionRealtimeWindowFromTimeInterval(interval: QuickTimeInterval, currentDate: moment_.Moment): number {
+function getSubscriptionRealtimeWindowFromTimeInterval(interval: QuickTimeInterval, tz?: string): number {
+  let currentDate;
   switch (interval) {
     case QuickTimeInterval.CURRENT_HOUR:
       return HOUR;
@@ -465,99 +464,94 @@ function getSubscriptionRealtimeWindowFromTimeInterval(interval: QuickTimeInterv
       return WEEK;
     case QuickTimeInterval.CURRENT_MONTH:
     case QuickTimeInterval.CURRENT_MONTH_SO_FAR:
+      currentDate = getCurrentTime(tz);
       return currentDate.endOf('month').diff(currentDate.clone().startOf('month'));
     case QuickTimeInterval.CURRENT_YEAR:
     case QuickTimeInterval.CURRENT_YEAR_SO_FAR:
+      currentDate = getCurrentTime(tz);
       return currentDate.endOf('year').diff(currentDate.clone().startOf('year'));
   }
 }
 
-export function calculateIntervalEndTime(interval: QuickTimeInterval, currentDate: moment_.Moment = null, tz: string = ''): number {
-    currentDate = currentDate ? currentDate.clone() : getCurrentTime(tz);
-    switch (interval) {
-      case QuickTimeInterval.YESTERDAY:
-        currentDate.subtract(1, 'days');
-        return currentDate.endOf('day').valueOf();
-      case QuickTimeInterval.DAY_BEFORE_YESTERDAY:
-        currentDate.subtract(2, 'days');
-        return currentDate.endOf('day').valueOf();
-      case QuickTimeInterval.THIS_DAY_LAST_WEEK:
-        currentDate.subtract(1, 'weeks');
-        return currentDate.endOf('day').valueOf();
-      case QuickTimeInterval.PREVIOUS_WEEK:
-        currentDate.subtract(1, 'weeks');
-        return currentDate.endOf('week').valueOf();
-      case QuickTimeInterval.PREVIOUS_WEEK_ISO:
-        currentDate.subtract(1, 'weeks');
-        return currentDate.endOf('isoWeek').valueOf();
-      case QuickTimeInterval.PREVIOUS_MONTH:
-        currentDate.subtract(1, 'months');
-        return currentDate.endOf('month').valueOf();
-      case QuickTimeInterval.PREVIOUS_YEAR:
-        currentDate.subtract(1, 'years');
-        return currentDate.endOf('year').valueOf();
-      case QuickTimeInterval.CURRENT_HOUR:
-        return currentDate.endOf('hour').valueOf();
-      case QuickTimeInterval.CURRENT_DAY:
-        return currentDate.endOf('day').valueOf();
-      case QuickTimeInterval.CURRENT_WEEK:
-        return currentDate.endOf('week').valueOf();
-      case QuickTimeInterval.CURRENT_WEEK_ISO:
-        return currentDate.endOf('isoWeek').valueOf();
-      case QuickTimeInterval.CURRENT_MONTH:
-        return currentDate.endOf('month').valueOf();
-      case QuickTimeInterval.CURRENT_YEAR:
-        return currentDate.endOf('year').valueOf();
-      case QuickTimeInterval.CURRENT_DAY_SO_FAR:
-      case QuickTimeInterval.CURRENT_WEEK_SO_FAR:
-      case QuickTimeInterval.CURRENT_WEEK_ISO_SO_FAR:
-      case QuickTimeInterval.CURRENT_MONTH_SO_FAR:
-      case QuickTimeInterval.CURRENT_YEAR_SO_FAR:
-        return currentDate.valueOf();
-  }
+export function calculateIntervalStartEndTime(interval: QuickTimeInterval, tz?: string): [number, number] {
+  const startEndTs: [number, number] = [0, 0];
+  const currentDate = getCurrentTime(tz);
+  const startDate = calculateIntervalStartTime(interval, currentDate);
+  startEndTs[0] = startDate.valueOf();
+  const endDate = calculateIntervalEndTime(interval, startDate, tz);
+  startEndTs[1] = endDate.valueOf();
+  return startEndTs;
 }
 
-export function calculateIntervalStartTime(interval: QuickTimeInterval, currentDate: moment_.Moment = null, tz: string = ''): number {
-  currentDate = currentDate ? currentDate.clone() : getCurrentTime(tz);
+export function calculateIntervalStartTime(interval: QuickTimeInterval, currentDate: moment_.Moment): moment_.Moment {
   switch (interval) {
     case QuickTimeInterval.YESTERDAY:
       currentDate.subtract(1, 'days');
-      return currentDate.startOf('day').valueOf();
+      return currentDate.startOf('day');
     case QuickTimeInterval.DAY_BEFORE_YESTERDAY:
       currentDate.subtract(2, 'days');
-      return currentDate.startOf('day').valueOf();
+      return currentDate.startOf('day');
     case QuickTimeInterval.THIS_DAY_LAST_WEEK:
       currentDate.subtract(1, 'weeks');
-      return currentDate.startOf('day').valueOf();
+      return currentDate.startOf('day');
     case QuickTimeInterval.PREVIOUS_WEEK:
       currentDate.subtract(1, 'weeks');
-      return currentDate.startOf('week').valueOf();
+      return currentDate.startOf('week');
     case QuickTimeInterval.PREVIOUS_WEEK_ISO:
       currentDate.subtract(1, 'weeks');
-      return currentDate.startOf('isoWeek').valueOf();
+      return currentDate.startOf('isoWeek');
     case QuickTimeInterval.PREVIOUS_MONTH:
       currentDate.subtract(1, 'months');
-      return currentDate.startOf('month').valueOf();
+      return currentDate.startOf('month');
     case QuickTimeInterval.PREVIOUS_YEAR:
       currentDate.subtract(1, 'years');
-      return currentDate.startOf('year').valueOf();
+      return currentDate.startOf('year');
     case QuickTimeInterval.CURRENT_HOUR:
-      return currentDate.startOf('hour').valueOf();
+      return currentDate.startOf('hour');
     case QuickTimeInterval.CURRENT_DAY:
     case QuickTimeInterval.CURRENT_DAY_SO_FAR:
-      return currentDate.startOf('day').valueOf();
+      return currentDate.startOf('day');
     case QuickTimeInterval.CURRENT_WEEK:
     case QuickTimeInterval.CURRENT_WEEK_SO_FAR:
-      return currentDate.startOf('week').valueOf();
+      return currentDate.startOf('week');
     case QuickTimeInterval.CURRENT_WEEK_ISO:
     case QuickTimeInterval.CURRENT_WEEK_ISO_SO_FAR:
-      return currentDate.startOf('isoWeek').valueOf();
+      return currentDate.startOf('isoWeek');
     case QuickTimeInterval.CURRENT_MONTH:
     case QuickTimeInterval.CURRENT_MONTH_SO_FAR:
-      return currentDate.startOf('month').valueOf();
+      return currentDate.startOf('month');
     case QuickTimeInterval.CURRENT_YEAR:
     case QuickTimeInterval.CURRENT_YEAR_SO_FAR:
-      return currentDate.startOf('year').valueOf();
+      return currentDate.startOf('year');
+  }
+}
+
+export function calculateIntervalEndTime(interval: QuickTimeInterval, startDate: moment_.Moment, tz?: string): number {
+  switch (interval) {
+    case QuickTimeInterval.YESTERDAY:
+    case QuickTimeInterval.DAY_BEFORE_YESTERDAY:
+    case QuickTimeInterval.THIS_DAY_LAST_WEEK:
+    case QuickTimeInterval.CURRENT_DAY:
+      return startDate.add(1, 'day').valueOf();
+    case QuickTimeInterval.PREVIOUS_WEEK:
+    case QuickTimeInterval.PREVIOUS_WEEK_ISO:
+    case QuickTimeInterval.CURRENT_WEEK:
+    case QuickTimeInterval.CURRENT_WEEK_ISO:
+      return startDate.add(1, 'week').valueOf();
+    case QuickTimeInterval.PREVIOUS_MONTH:
+    case QuickTimeInterval.CURRENT_MONTH:
+      return startDate.add(1, 'month').valueOf();
+    case QuickTimeInterval.PREVIOUS_YEAR:
+    case QuickTimeInterval.CURRENT_YEAR:
+      return startDate.add(1, 'year').valueOf();
+    case QuickTimeInterval.CURRENT_HOUR:
+      return startDate.add(1, 'hour').valueOf();
+    case QuickTimeInterval.CURRENT_DAY_SO_FAR:
+    case QuickTimeInterval.CURRENT_WEEK_SO_FAR:
+    case QuickTimeInterval.CURRENT_WEEK_ISO_SO_FAR:
+    case QuickTimeInterval.CURRENT_MONTH_SO_FAR:
+    case QuickTimeInterval.CURRENT_YEAR_SO_FAR:
+      return getCurrentTime(tz).valueOf();
   }
 }
 
@@ -590,82 +584,58 @@ export function quickTimeIntervalPeriod(interval: QuickTimeInterval): number {
 }
 
 export function calculateIntervalComparisonStartTime(interval: QuickTimeInterval,
-                                                     currentDate: moment_.Moment): number {
+                                                     startDate: moment_.Moment): moment_.Moment {
   switch (interval) {
     case QuickTimeInterval.YESTERDAY:
     case QuickTimeInterval.DAY_BEFORE_YESTERDAY:
     case QuickTimeInterval.CURRENT_DAY:
     case QuickTimeInterval.CURRENT_DAY_SO_FAR:
-      currentDate.subtract(1, 'days');
-      return currentDate.startOf('day').valueOf();
+      startDate.subtract(1, 'days');
+      return startDate.startOf('day');
     case QuickTimeInterval.THIS_DAY_LAST_WEEK:
-      currentDate.subtract(1, 'weeks');
-      return currentDate.startOf('day').valueOf();
+      startDate.subtract(1, 'weeks');
+      return startDate.startOf('day');
     case QuickTimeInterval.PREVIOUS_WEEK:
     case QuickTimeInterval.CURRENT_WEEK:
     case QuickTimeInterval.CURRENT_WEEK_SO_FAR:
-      currentDate.subtract(1, 'weeks');
-      return currentDate.startOf('week').valueOf();
+      startDate.subtract(1, 'weeks');
+      return startDate.startOf('week');
     case QuickTimeInterval.PREVIOUS_WEEK_ISO:
     case QuickTimeInterval.CURRENT_WEEK_ISO:
     case QuickTimeInterval.CURRENT_WEEK_ISO_SO_FAR:
-      currentDate.subtract(1, 'weeks');
-      return currentDate.startOf('isoWeek').valueOf();
+      startDate.subtract(1, 'weeks');
+      return startDate.startOf('isoWeek');
     case QuickTimeInterval.PREVIOUS_MONTH:
     case QuickTimeInterval.CURRENT_MONTH:
     case QuickTimeInterval.CURRENT_MONTH_SO_FAR:
-      currentDate.subtract(1, 'months');
-      return currentDate.startOf('month').valueOf();
+      startDate.subtract(1, 'months');
+      return startDate.startOf('month');
     case QuickTimeInterval.PREVIOUS_YEAR:
     case QuickTimeInterval.CURRENT_YEAR:
     case QuickTimeInterval.CURRENT_YEAR_SO_FAR:
-      currentDate.subtract(1, 'years');
-      return currentDate.startOf('year').valueOf();
+      startDate.subtract(1, 'years');
+      return startDate.startOf('year');
     case QuickTimeInterval.CURRENT_HOUR:
-      currentDate.subtract(1, 'hour');
-      return currentDate.startOf('hour').valueOf();
+      startDate.subtract(1, 'hour');
+      return startDate.startOf('hour');
   }
 }
 
 export function calculateIntervalComparisonEndTime(interval: QuickTimeInterval,
-                                                   currentDate: moment_.Moment): number {
+                                                   comparisonStartDate: moment_.Moment,
+                                                   endDate: moment_.Moment): number {
   switch (interval) {
-    case QuickTimeInterval.YESTERDAY:
-    case QuickTimeInterval.DAY_BEFORE_YESTERDAY:
-    case QuickTimeInterval.CURRENT_DAY:
-      currentDate.subtract(1, 'days');
-      return currentDate.endOf('day').valueOf();
     case QuickTimeInterval.CURRENT_DAY_SO_FAR:
-      return currentDate.subtract(1, 'days').valueOf();
-    case QuickTimeInterval.THIS_DAY_LAST_WEEK:
-      currentDate.subtract(1, 'weeks');
-      return currentDate.endOf('day').valueOf();
-    case QuickTimeInterval.PREVIOUS_WEEK:
-    case QuickTimeInterval.CURRENT_WEEK:
-      currentDate.subtract(1, 'weeks');
-      return currentDate.endOf('week').valueOf();
-    case QuickTimeInterval.PREVIOUS_WEEK_ISO:
-    case QuickTimeInterval.CURRENT_WEEK_ISO:
-      currentDate.subtract(1, 'weeks');
-      return currentDate.endOf('isoWeek').valueOf();
+      return endDate.subtract(1, 'days').valueOf();
     case QuickTimeInterval.CURRENT_WEEK_SO_FAR:
     case QuickTimeInterval.CURRENT_WEEK_ISO_SO_FAR:
-      return currentDate.subtract(1, 'week').valueOf();
-    case QuickTimeInterval.PREVIOUS_MONTH:
-    case QuickTimeInterval.CURRENT_MONTH:
-      currentDate.subtract(1, 'months');
-      return currentDate.endOf('month').valueOf();
+      return endDate.subtract(1, 'week').valueOf();
     case QuickTimeInterval.CURRENT_MONTH_SO_FAR:
-      return currentDate.subtract(1, 'month').valueOf();
-    case QuickTimeInterval.PREVIOUS_YEAR:
-    case QuickTimeInterval.CURRENT_YEAR:
-      currentDate.subtract(1, 'years');
-      return currentDate.endOf('year').valueOf();
+      return endDate.subtract(1, 'month').valueOf();
     case QuickTimeInterval.CURRENT_YEAR_SO_FAR:
-      return currentDate.subtract(1, 'year').valueOf();
-    case QuickTimeInterval.CURRENT_HOUR:
-      currentDate.subtract(1, 'hour');
-      return currentDate.endOf('hour').valueOf();
+      return endDate.subtract(1, 'year').valueOf();
+    default:
+      return calculateIntervalEndTime(interval, comparisonStartDate);
   }
 }
 
@@ -689,8 +659,9 @@ export function createTimewindowForComparison(subscriptionTimewindow: Subscripti
           startDate.tz(subscriptionTimewindow.timezone);
           endDate.tz(subscriptionTimewindow.timezone);
         }
-        startTimeMs = calculateIntervalComparisonStartTime(subscriptionTimewindow.quickInterval, startDate);
-        endTimeMs = calculateIntervalComparisonEndTime(subscriptionTimewindow.quickInterval, endDate);
+        const comparisonStartDate = calculateIntervalComparisonStartTime(subscriptionTimewindow.quickInterval, startDate);
+        startTimeMs = comparisonStartDate.valueOf();
+        endTimeMs = calculateIntervalComparisonEndTime(subscriptionTimewindow.quickInterval, comparisonStartDate, endDate);
       } else {
         const timeInterval = subscriptionTimewindow.fixedWindow.endTimeMs - subscriptionTimewindow.fixedWindow.startTimeMs;
         endTimeMs = subscriptionTimewindow.fixedWindow.startTimeMs;
@@ -730,22 +701,6 @@ export function cloneSelectedTimewindow(timewindow: Timewindow): Timewindow {
   return cloned;
 }
 
-export function cloneSelectedHistoryTimewindow(historyWindow: HistoryWindow): HistoryWindow {
-  const cloned: HistoryWindow = {};
-  if (isDefined(historyWindow.historyType)) {
-    cloned.historyType = historyWindow.historyType;
-    cloned.interval = historyWindow.interval;
-    if (historyWindow.historyType === HistoryWindowType.LAST_INTERVAL) {
-      cloned.timewindowMs = historyWindow.timewindowMs;
-    } else if (historyWindow.historyType === HistoryWindowType.INTERVAL) {
-      cloned.quickInterval = historyWindow.quickInterval;
-    } else if (historyWindow.historyType === HistoryWindowType.FIXED) {
-      cloned.fixedTimewindow = deepClone(historyWindow.fixedTimewindow);
-    }
-  }
-  return cloned;
-}
-
 export interface TimeInterval {
   name: string;
   translateParams: {[key: string]: any};
@@ -927,6 +882,14 @@ export function getCurrentTime(tz?: string): moment_.Moment {
   }
 }
 
+export function getTime(ts: number, tz?: string): moment_.Moment {
+  if (tz) {
+    return moment(ts).tz(tz);
+  } else {
+    return moment(ts);
+  }
+}
+
 export function getTimezone(tz: string): moment_.Moment {
     return moment.tz(tz);
 }