|
|
|
@ -17,9 +17,7 @@ |
|
|
|
import { TimeService } from '@core/services/time.service'; |
|
|
|
import { deepClone, isDefined, isUndefined } from '@app/core/utils'; |
|
|
|
import * as moment_ from 'moment'; |
|
|
|
import { Observable } from 'rxjs/internal/Observable'; |
|
|
|
import { from, of } from 'rxjs'; |
|
|
|
import { map, mergeMap, tap } from 'rxjs/operators'; |
|
|
|
import * as monentTz from 'moment-timezone'; |
|
|
|
|
|
|
|
const moment = moment_; |
|
|
|
|
|
|
|
@ -27,6 +25,7 @@ export const SECOND = 1000; |
|
|
|
export const MINUTE = 60 * SECOND; |
|
|
|
export const HOUR = 60 * MINUTE; |
|
|
|
export const DAY = 24 * HOUR; |
|
|
|
export const WEEK = 7 * DAY; |
|
|
|
export const YEAR = DAY * 365; |
|
|
|
|
|
|
|
export enum TimewindowType { |
|
|
|
@ -34,14 +33,25 @@ export enum TimewindowType { |
|
|
|
HISTORY |
|
|
|
} |
|
|
|
|
|
|
|
export enum RealtimeWindowType { |
|
|
|
LAST_INTERVAL, |
|
|
|
INTERVAL |
|
|
|
} |
|
|
|
|
|
|
|
export enum HistoryWindowType { |
|
|
|
LAST_INTERVAL, |
|
|
|
FIXED |
|
|
|
FIXED, |
|
|
|
INTERVAL |
|
|
|
} |
|
|
|
|
|
|
|
export interface IntervalWindow { |
|
|
|
interval?: number; |
|
|
|
timewindowMs?: number; |
|
|
|
quickInterval?: QuickTimeInterval; |
|
|
|
} |
|
|
|
|
|
|
|
export interface RealtimeWindow extends IntervalWindow{ |
|
|
|
realtimeType?: RealtimeWindowType; |
|
|
|
} |
|
|
|
|
|
|
|
export interface FixedWindow { |
|
|
|
@ -85,10 +95,12 @@ export interface Timewindow { |
|
|
|
hideInterval?: boolean; |
|
|
|
hideAggregation?: boolean; |
|
|
|
hideAggInterval?: boolean; |
|
|
|
hideTimezone?: boolean; |
|
|
|
selectedTab?: TimewindowType; |
|
|
|
realtime?: IntervalWindow; |
|
|
|
realtime?: RealtimeWindow; |
|
|
|
history?: HistoryWindow; |
|
|
|
aggregation?: Aggregation; |
|
|
|
timezone?: string; |
|
|
|
} |
|
|
|
|
|
|
|
export interface SubscriptionAggregation extends Aggregation { |
|
|
|
@ -99,6 +111,9 @@ export interface SubscriptionAggregation extends Aggregation { |
|
|
|
|
|
|
|
export interface SubscriptionTimewindow { |
|
|
|
startTs?: number; |
|
|
|
quickInterval?: QuickTimeInterval; |
|
|
|
timezone?: string; |
|
|
|
tsOffset?: number; |
|
|
|
realtimeWindowMs?: number; |
|
|
|
fixedWindow?: FixedWindow; |
|
|
|
aggregation?: SubscriptionAggregation; |
|
|
|
@ -108,9 +123,46 @@ export interface WidgetTimewindow { |
|
|
|
minTime?: number; |
|
|
|
maxTime?: number; |
|
|
|
interval?: number; |
|
|
|
timezone?: string; |
|
|
|
stDiff?: number; |
|
|
|
} |
|
|
|
|
|
|
|
export enum QuickTimeInterval { |
|
|
|
YESTERDAY = 'YESTERDAY', |
|
|
|
DAY_BEFORE_YESTERDAY = 'DAY_BEFORE_YESTERDAY', |
|
|
|
THIS_DAY_LAST_WEEK = 'THIS_DAY_LAST_WEEK', |
|
|
|
PREVIOUS_WEEK = 'PREVIOUS_WEEK', |
|
|
|
PREVIOUS_MONTH = 'PREVIOUS_MONTH', |
|
|
|
PREVIOUS_YEAR = 'PREVIOUS_YEAR', |
|
|
|
CURRENT_HOUR = 'CURRENT_HOUR', |
|
|
|
CURRENT_DAY = 'CURRENT_DAY', |
|
|
|
CURRENT_DAY_SO_FAR = 'CURRENT_DAY_SO_FAR', |
|
|
|
CURRENT_WEEK = 'CURRENT_WEEK', |
|
|
|
CURRENT_WEEK_SO_FAR = 'CURRENT_WEEK_SO_WAR', |
|
|
|
CURRENT_MONTH = 'CURRENT_MONTH', |
|
|
|
CURRENT_MONTH_SO_FAR = 'CURRENT_MONTH_SO_FAR', |
|
|
|
CURRENT_YEAR = 'CURRENT_YEAR', |
|
|
|
CURRENT_YEAR_SO_FAR = 'CURRENT_YEAR_SO_FAR' |
|
|
|
} |
|
|
|
|
|
|
|
export const QuickTimeIntervalTranslationMap = new Map<QuickTimeInterval, string>([ |
|
|
|
[QuickTimeInterval.YESTERDAY, 'timeinterval.predefined.yesterday'], |
|
|
|
[QuickTimeInterval.DAY_BEFORE_YESTERDAY, 'timeinterval.predefined.day-before-yesterday'], |
|
|
|
[QuickTimeInterval.THIS_DAY_LAST_WEEK, 'timeinterval.predefined.this-day-last-week'], |
|
|
|
[QuickTimeInterval.PREVIOUS_WEEK, 'timeinterval.predefined.previous-week'], |
|
|
|
[QuickTimeInterval.PREVIOUS_MONTH, 'timeinterval.predefined.previous-month'], |
|
|
|
[QuickTimeInterval.PREVIOUS_YEAR, 'timeinterval.predefined.previous-year'], |
|
|
|
[QuickTimeInterval.CURRENT_HOUR, 'timeinterval.predefined.current-hour'], |
|
|
|
[QuickTimeInterval.CURRENT_DAY, 'timeinterval.predefined.current-day'], |
|
|
|
[QuickTimeInterval.CURRENT_DAY_SO_FAR, 'timeinterval.predefined.current-day-so-far'], |
|
|
|
[QuickTimeInterval.CURRENT_WEEK, 'timeinterval.predefined.current-week'], |
|
|
|
[QuickTimeInterval.CURRENT_WEEK_SO_FAR, 'timeinterval.predefined.current-week-so-far'], |
|
|
|
[QuickTimeInterval.CURRENT_MONTH, 'timeinterval.predefined.current-month'], |
|
|
|
[QuickTimeInterval.CURRENT_MONTH_SO_FAR, 'timeinterval.predefined.current-month-so-far'], |
|
|
|
[QuickTimeInterval.CURRENT_YEAR, 'timeinterval.predefined.current-year'], |
|
|
|
[QuickTimeInterval.CURRENT_YEAR_SO_FAR, 'timeinterval.predefined.current-year-so-far'] |
|
|
|
]); |
|
|
|
|
|
|
|
export function historyInterval(timewindowMs: number): Timewindow { |
|
|
|
const timewindow: Timewindow = { |
|
|
|
selectedTab: TimewindowType.HISTORY, |
|
|
|
@ -129,10 +181,13 @@ export function defaultTimewindow(timeService: TimeService): Timewindow { |
|
|
|
hideInterval: false, |
|
|
|
hideAggregation: false, |
|
|
|
hideAggInterval: false, |
|
|
|
hideTimezone: false, |
|
|
|
selectedTab: TimewindowType.REALTIME, |
|
|
|
realtime: { |
|
|
|
realtimeType: RealtimeWindowType.LAST_INTERVAL, |
|
|
|
interval: SECOND, |
|
|
|
timewindowMs: MINUTE |
|
|
|
timewindowMs: MINUTE, |
|
|
|
quickInterval: QuickTimeInterval.CURRENT_DAY |
|
|
|
}, |
|
|
|
history: { |
|
|
|
historyType: HistoryWindowType.LAST_INTERVAL, |
|
|
|
@ -141,7 +196,8 @@ export function defaultTimewindow(timeService: TimeService): Timewindow { |
|
|
|
fixedTimewindow: { |
|
|
|
startTimeMs: currentTime - DAY, |
|
|
|
endTimeMs: currentTime |
|
|
|
} |
|
|
|
}, |
|
|
|
quickInterval: QuickTimeInterval.CURRENT_DAY |
|
|
|
}, |
|
|
|
aggregation: { |
|
|
|
type: AggregationType.AVG, |
|
|
|
@ -157,6 +213,7 @@ export function initModelFromDefaultTimewindow(value: Timewindow, timeService: T |
|
|
|
model.hideInterval = value.hideInterval; |
|
|
|
model.hideAggregation = value.hideAggregation; |
|
|
|
model.hideAggInterval = value.hideAggInterval; |
|
|
|
model.hideTimezone = value.hideTimezone; |
|
|
|
if (isUndefined(value.selectedTab)) { |
|
|
|
if (value.realtime) { |
|
|
|
model.selectedTab = TimewindowType.REALTIME; |
|
|
|
@ -170,7 +227,20 @@ export function initModelFromDefaultTimewindow(value: Timewindow, timeService: T |
|
|
|
if (isDefined(value.realtime.interval)) { |
|
|
|
model.realtime.interval = value.realtime.interval; |
|
|
|
} |
|
|
|
model.realtime.timewindowMs = value.realtime.timewindowMs; |
|
|
|
if (isUndefined(value.realtime.realtimeType)) { |
|
|
|
if (isDefined(value.realtime.quickInterval)) { |
|
|
|
model.realtime.realtimeType = RealtimeWindowType.INTERVAL; |
|
|
|
} else { |
|
|
|
model.realtime.realtimeType = RealtimeWindowType.LAST_INTERVAL; |
|
|
|
} |
|
|
|
} else { |
|
|
|
model.realtime.realtimeType = value.realtime.realtimeType; |
|
|
|
} |
|
|
|
if (model.realtime.realtimeType === RealtimeWindowType.INTERVAL) { |
|
|
|
model.realtime.quickInterval = value.realtime.quickInterval; |
|
|
|
} else { |
|
|
|
model.realtime.timewindowMs = value.realtime.timewindowMs; |
|
|
|
} |
|
|
|
} else { |
|
|
|
if (isDefined(value.history.interval)) { |
|
|
|
model.history.interval = value.history.interval; |
|
|
|
@ -178,6 +248,8 @@ export function initModelFromDefaultTimewindow(value: Timewindow, timeService: T |
|
|
|
if (isUndefined(value.history.historyType)) { |
|
|
|
if (isDefined(value.history.timewindowMs)) { |
|
|
|
model.history.historyType = HistoryWindowType.LAST_INTERVAL; |
|
|
|
} else if (isDefined(value.history.quickInterval)) { |
|
|
|
model.history.historyType = HistoryWindowType.INTERVAL; |
|
|
|
} else { |
|
|
|
model.history.historyType = HistoryWindowType.FIXED; |
|
|
|
} |
|
|
|
@ -186,6 +258,8 @@ export function initModelFromDefaultTimewindow(value: Timewindow, timeService: T |
|
|
|
} |
|
|
|
if (model.history.historyType === HistoryWindowType.LAST_INTERVAL) { |
|
|
|
model.history.timewindowMs = value.history.timewindowMs; |
|
|
|
} else if (model.history.historyType === HistoryWindowType.INTERVAL) { |
|
|
|
model.history.quickInterval = value.history.quickInterval; |
|
|
|
} else { |
|
|
|
model.history.fixedTimewindow.startTimeMs = value.history.fixedTimewindow.startTimeMs; |
|
|
|
model.history.fixedTimewindow.endTimeMs = value.history.fixedTimewindow.endTimeMs; |
|
|
|
@ -197,6 +271,7 @@ export function initModelFromDefaultTimewindow(value: Timewindow, timeService: T |
|
|
|
} |
|
|
|
model.aggregation.limit = value.aggregation.limit || Math.floor(timeService.getMaxDatapointsLimit() / 2); |
|
|
|
} |
|
|
|
model.timezone = value.timezone; |
|
|
|
} |
|
|
|
return model; |
|
|
|
} |
|
|
|
@ -223,6 +298,7 @@ export function toHistoryTimewindow(timewindow: Timewindow, startTimeMs: number, |
|
|
|
hideInterval: timewindow.hideInterval || false, |
|
|
|
hideAggregation: timewindow.hideAggregation || false, |
|
|
|
hideAggInterval: timewindow.hideAggInterval || false, |
|
|
|
hideTimezone: timewindow.hideTimezone || false, |
|
|
|
selectedTab: TimewindowType.HISTORY, |
|
|
|
history: { |
|
|
|
historyType: HistoryWindowType.FIXED, |
|
|
|
@ -235,7 +311,8 @@ export function toHistoryTimewindow(timewindow: Timewindow, startTimeMs: number, |
|
|
|
aggregation: { |
|
|
|
type: aggType, |
|
|
|
limit |
|
|
|
} |
|
|
|
}, |
|
|
|
timezone: timewindow.timezone |
|
|
|
}; |
|
|
|
return historyTimewindow; |
|
|
|
} |
|
|
|
@ -249,8 +326,15 @@ export function createSubscriptionTimewindow(timewindow: Timewindow, stDiff: num |
|
|
|
interval: SECOND, |
|
|
|
limit: timeService.getMaxDatapointsLimit(), |
|
|
|
type: AggregationType.AVG |
|
|
|
} |
|
|
|
}, |
|
|
|
timezone: timewindow.timezone, |
|
|
|
tsOffset: 0 |
|
|
|
}; |
|
|
|
if (timewindow.timezone) { |
|
|
|
const tz = getTimezone(timewindow.timezone); |
|
|
|
const localOffset = moment().utcOffset(); |
|
|
|
subscriptionTimewindow.tsOffset = (tz.utcOffset() - localOffset) * 60 * 1000; |
|
|
|
} |
|
|
|
let aggTimewindow = 0; |
|
|
|
if (stateData) { |
|
|
|
subscriptionTimewindow.aggregation.type = AggregationType.NONE; |
|
|
|
@ -267,33 +351,65 @@ export function createSubscriptionTimewindow(timewindow: Timewindow, stDiff: num |
|
|
|
selectedTab = isDefined(timewindow.realtime) ? TimewindowType.REALTIME : TimewindowType.HISTORY; |
|
|
|
} |
|
|
|
if (selectedTab === TimewindowType.REALTIME) { |
|
|
|
subscriptionTimewindow.realtimeWindowMs = timewindow.realtime.timewindowMs; |
|
|
|
let realtimeType = timewindow.realtime.realtimeType; |
|
|
|
if (isUndefined(realtimeType)) { |
|
|
|
if (isDefined(timewindow.realtime.quickInterval)) { |
|
|
|
realtimeType = RealtimeWindowType.INTERVAL; |
|
|
|
} else { |
|
|
|
realtimeType = RealtimeWindowType.LAST_INTERVAL; |
|
|
|
} |
|
|
|
} |
|
|
|
if (realtimeType === RealtimeWindowType.INTERVAL) { |
|
|
|
const currentDate = getCurrentTime(timewindow.timezone); |
|
|
|
subscriptionTimewindow.realtimeWindowMs = |
|
|
|
getSubscriptionRealtimeWindowFromTimeInterval(timewindow.realtime.quickInterval, currentDate); |
|
|
|
subscriptionTimewindow.quickInterval = timewindow.realtime.quickInterval; |
|
|
|
subscriptionTimewindow.startTs = calculateIntervalStartTime(timewindow.realtime.quickInterval, currentDate); |
|
|
|
} else { |
|
|
|
subscriptionTimewindow.realtimeWindowMs = timewindow.realtime.timewindowMs; |
|
|
|
subscriptionTimewindow.startTs = Date.now() + stDiff - subscriptionTimewindow.realtimeWindowMs; |
|
|
|
} |
|
|
|
subscriptionTimewindow.aggregation.interval = |
|
|
|
timeService.boundIntervalToTimewindow(subscriptionTimewindow.realtimeWindowMs, timewindow.realtime.interval, |
|
|
|
subscriptionTimewindow.aggregation.type); |
|
|
|
subscriptionTimewindow.startTs = Date.now() + stDiff - subscriptionTimewindow.realtimeWindowMs; |
|
|
|
const startDiff = subscriptionTimewindow.startTs % subscriptionTimewindow.aggregation.interval; |
|
|
|
aggTimewindow = subscriptionTimewindow.realtimeWindowMs; |
|
|
|
if (startDiff) { |
|
|
|
subscriptionTimewindow.startTs -= startDiff; |
|
|
|
aggTimewindow += subscriptionTimewindow.aggregation.interval; |
|
|
|
if (realtimeType !== RealtimeWindowType.INTERVAL) { |
|
|
|
const startDiff = subscriptionTimewindow.startTs % subscriptionTimewindow.aggregation.interval; |
|
|
|
if (startDiff) { |
|
|
|
subscriptionTimewindow.startTs -= startDiff; |
|
|
|
aggTimewindow += subscriptionTimewindow.aggregation.interval; |
|
|
|
} |
|
|
|
} |
|
|
|
} else { |
|
|
|
let historyType = timewindow.history.historyType; |
|
|
|
if (isUndefined(historyType)) { |
|
|
|
historyType = isDefined(timewindow.history.timewindowMs) ? HistoryWindowType.LAST_INTERVAL : HistoryWindowType.FIXED; |
|
|
|
if (isDefined(timewindow.history.timewindowMs)) { |
|
|
|
historyType = HistoryWindowType.LAST_INTERVAL; |
|
|
|
} else if (isDefined(timewindow.history.quickInterval)) { |
|
|
|
historyType = HistoryWindowType.INTERVAL; |
|
|
|
} else { |
|
|
|
historyType = HistoryWindowType.FIXED; |
|
|
|
} |
|
|
|
} |
|
|
|
if (historyType === HistoryWindowType.LAST_INTERVAL) { |
|
|
|
const currentTime = Date.now(); |
|
|
|
const currentDate = getCurrentTime(timewindow.timezone); |
|
|
|
const currentTime = currentDate.valueOf(); |
|
|
|
subscriptionTimewindow.fixedWindow = { |
|
|
|
startTimeMs: currentTime - timewindow.history.timewindowMs, |
|
|
|
endTimeMs: currentTime |
|
|
|
}; |
|
|
|
aggTimewindow = timewindow.history.timewindowMs; |
|
|
|
} else if (historyType === HistoryWindowType.INTERVAL) { |
|
|
|
const currentDate = getCurrentTime(timewindow.timezone); |
|
|
|
subscriptionTimewindow.fixedWindow = { |
|
|
|
startTimeMs: calculateIntervalStartTime(timewindow.history.quickInterval, currentDate), |
|
|
|
endTimeMs: calculateIntervalEndTime(timewindow.history.quickInterval, currentDate) |
|
|
|
}; |
|
|
|
aggTimewindow = subscriptionTimewindow.fixedWindow.endTimeMs - subscriptionTimewindow.fixedWindow.startTimeMs; |
|
|
|
} else { |
|
|
|
subscriptionTimewindow.fixedWindow = { |
|
|
|
startTimeMs: timewindow.history.fixedTimewindow.startTimeMs, |
|
|
|
endTimeMs: timewindow.history.fixedTimewindow.endTimeMs |
|
|
|
startTimeMs: timewindow.history.fixedTimewindow.startTimeMs - subscriptionTimewindow.tsOffset, |
|
|
|
endTimeMs: timewindow.history.fixedTimewindow.endTimeMs - subscriptionTimewindow.tsOffset |
|
|
|
}; |
|
|
|
aggTimewindow = subscriptionTimewindow.fixedWindow.endTimeMs - subscriptionTimewindow.fixedWindow.startTimeMs; |
|
|
|
} |
|
|
|
@ -309,6 +425,127 @@ export function createSubscriptionTimewindow(timewindow: Timewindow, stDiff: num |
|
|
|
return subscriptionTimewindow; |
|
|
|
} |
|
|
|
|
|
|
|
function getSubscriptionRealtimeWindowFromTimeInterval(interval: QuickTimeInterval, currentDate: moment_.Moment): number { |
|
|
|
switch (interval) { |
|
|
|
case QuickTimeInterval.CURRENT_HOUR: |
|
|
|
return HOUR; |
|
|
|
case QuickTimeInterval.CURRENT_DAY: |
|
|
|
case QuickTimeInterval.CURRENT_DAY_SO_FAR: |
|
|
|
return DAY; |
|
|
|
case QuickTimeInterval.CURRENT_WEEK: |
|
|
|
case QuickTimeInterval.CURRENT_WEEK_SO_FAR: |
|
|
|
return WEEK; |
|
|
|
case QuickTimeInterval.CURRENT_MONTH: |
|
|
|
case QuickTimeInterval.CURRENT_MONTH_SO_FAR: |
|
|
|
return currentDate.endOf('month').diff(currentDate.clone().startOf('month')); |
|
|
|
case QuickTimeInterval.CURRENT_YEAR: |
|
|
|
case QuickTimeInterval.CURRENT_YEAR_SO_FAR: |
|
|
|
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_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_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_MONTH_SO_FAR: |
|
|
|
case QuickTimeInterval.CURRENT_YEAR_SO_FAR: |
|
|
|
return currentDate.valueOf(); |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
export function calculateIntervalStartTime(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.startOf('day').valueOf(); |
|
|
|
case QuickTimeInterval.DAY_BEFORE_YESTERDAY: |
|
|
|
currentDate.subtract(2, 'days'); |
|
|
|
return currentDate.startOf('day').valueOf(); |
|
|
|
case QuickTimeInterval.THIS_DAY_LAST_WEEK: |
|
|
|
currentDate.subtract(1, 'weeks'); |
|
|
|
return currentDate.startOf('day').valueOf(); |
|
|
|
case QuickTimeInterval.PREVIOUS_WEEK: |
|
|
|
currentDate.subtract(1, 'weeks'); |
|
|
|
return currentDate.startOf('week').valueOf(); |
|
|
|
case QuickTimeInterval.PREVIOUS_MONTH: |
|
|
|
currentDate.subtract(1, 'months'); |
|
|
|
return currentDate.startOf('month').valueOf(); |
|
|
|
case QuickTimeInterval.PREVIOUS_YEAR: |
|
|
|
currentDate.subtract(1, 'years'); |
|
|
|
return currentDate.startOf('year').valueOf(); |
|
|
|
case QuickTimeInterval.CURRENT_HOUR: |
|
|
|
return currentDate.startOf('hour').valueOf(); |
|
|
|
case QuickTimeInterval.CURRENT_DAY: |
|
|
|
case QuickTimeInterval.CURRENT_DAY_SO_FAR: |
|
|
|
return currentDate.startOf('day').valueOf(); |
|
|
|
case QuickTimeInterval.CURRENT_WEEK: |
|
|
|
case QuickTimeInterval.CURRENT_WEEK_SO_FAR: |
|
|
|
return currentDate.startOf('week').valueOf(); |
|
|
|
case QuickTimeInterval.CURRENT_MONTH: |
|
|
|
case QuickTimeInterval.CURRENT_MONTH_SO_FAR: |
|
|
|
return currentDate.startOf('month').valueOf(); |
|
|
|
case QuickTimeInterval.CURRENT_YEAR: |
|
|
|
case QuickTimeInterval.CURRENT_YEAR_SO_FAR: |
|
|
|
return currentDate.startOf('year').valueOf(); |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
export function quickTimeIntervalPeriod(interval: QuickTimeInterval): number { |
|
|
|
switch (interval) { |
|
|
|
case QuickTimeInterval.CURRENT_HOUR: |
|
|
|
return HOUR; |
|
|
|
case QuickTimeInterval.YESTERDAY: |
|
|
|
case QuickTimeInterval.DAY_BEFORE_YESTERDAY: |
|
|
|
case QuickTimeInterval.THIS_DAY_LAST_WEEK: |
|
|
|
case QuickTimeInterval.CURRENT_DAY: |
|
|
|
case QuickTimeInterval.CURRENT_DAY_SO_FAR: |
|
|
|
return DAY; |
|
|
|
case QuickTimeInterval.PREVIOUS_WEEK: |
|
|
|
case QuickTimeInterval.CURRENT_WEEK: |
|
|
|
case QuickTimeInterval.CURRENT_WEEK_SO_FAR: |
|
|
|
return WEEK; |
|
|
|
case QuickTimeInterval.PREVIOUS_MONTH: |
|
|
|
case QuickTimeInterval.CURRENT_MONTH: |
|
|
|
case QuickTimeInterval.CURRENT_MONTH_SO_FAR: |
|
|
|
return DAY * 30; |
|
|
|
case QuickTimeInterval.PREVIOUS_YEAR: |
|
|
|
case QuickTimeInterval.CURRENT_YEAR: |
|
|
|
case QuickTimeInterval.CURRENT_YEAR_SO_FAR: |
|
|
|
return YEAR; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
export function createTimewindowForComparison(subscriptionTimewindow: SubscriptionTimewindow, |
|
|
|
timeUnit: moment_.unitOfTime.DurationConstructor): SubscriptionTimewindow { |
|
|
|
const timewindowForComparison: SubscriptionTimewindow = { |
|
|
|
@ -339,6 +576,7 @@ export function cloneSelectedTimewindow(timewindow: Timewindow): Timewindow { |
|
|
|
cloned.hideInterval = timewindow.hideInterval || false; |
|
|
|
cloned.hideAggregation = timewindow.hideAggregation || false; |
|
|
|
cloned.hideAggInterval = timewindow.hideAggInterval || false; |
|
|
|
cloned.hideTimezone = timewindow.hideTimezone || false; |
|
|
|
if (isDefined(timewindow.selectedTab)) { |
|
|
|
cloned.selectedTab = timewindow.selectedTab; |
|
|
|
if (timewindow.selectedTab === TimewindowType.REALTIME) { |
|
|
|
@ -348,6 +586,7 @@ export function cloneSelectedTimewindow(timewindow: Timewindow): Timewindow { |
|
|
|
} |
|
|
|
} |
|
|
|
cloned.aggregation = deepClone(timewindow.aggregation); |
|
|
|
cloned.timezone = timewindow.timezone; |
|
|
|
return cloned; |
|
|
|
} |
|
|
|
|
|
|
|
@ -358,6 +597,8 @@ export function cloneSelectedHistoryTimewindow(historyWindow: HistoryWindow): Hi |
|
|
|
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); |
|
|
|
} |
|
|
|
@ -375,7 +616,7 @@ export const defaultTimeIntervals = new Array<TimeInterval>( |
|
|
|
{ |
|
|
|
name: 'timeinterval.seconds-interval', |
|
|
|
translateParams: {seconds: 1}, |
|
|
|
value: 1 * SECOND |
|
|
|
value: SECOND |
|
|
|
}, |
|
|
|
{ |
|
|
|
name: 'timeinterval.seconds-interval', |
|
|
|
@ -400,7 +641,7 @@ export const defaultTimeIntervals = new Array<TimeInterval>( |
|
|
|
{ |
|
|
|
name: 'timeinterval.minutes-interval', |
|
|
|
translateParams: {minutes: 1}, |
|
|
|
value: 1 * MINUTE |
|
|
|
value: MINUTE |
|
|
|
}, |
|
|
|
{ |
|
|
|
name: 'timeinterval.minutes-interval', |
|
|
|
@ -430,7 +671,7 @@ export const defaultTimeIntervals = new Array<TimeInterval>( |
|
|
|
{ |
|
|
|
name: 'timeinterval.hours-interval', |
|
|
|
translateParams: {hours: 1}, |
|
|
|
value: 1 * HOUR |
|
|
|
value: HOUR |
|
|
|
}, |
|
|
|
{ |
|
|
|
name: 'timeinterval.hours-interval', |
|
|
|
@ -455,7 +696,7 @@ export const defaultTimeIntervals = new Array<TimeInterval>( |
|
|
|
{ |
|
|
|
name: 'timeinterval.days-interval', |
|
|
|
translateParams: {days: 1}, |
|
|
|
value: 1 * DAY |
|
|
|
value: DAY |
|
|
|
}, |
|
|
|
{ |
|
|
|
name: 'timeinterval.days-interval', |
|
|
|
@ -495,60 +736,50 @@ export interface TimezoneInfo { |
|
|
|
let timezones: TimezoneInfo[] = null; |
|
|
|
let defaultTimezone: string = null; |
|
|
|
|
|
|
|
export function getTimezones(): Observable<TimezoneInfo[]> { |
|
|
|
if (timezones) { |
|
|
|
return of(timezones); |
|
|
|
} else { |
|
|
|
return from(import('moment-timezone')).pipe( |
|
|
|
map((monentTz) => { |
|
|
|
return monentTz.tz.names().map((zoneName) => { |
|
|
|
const tz = monentTz.tz(zoneName); |
|
|
|
return { |
|
|
|
id: zoneName, |
|
|
|
name: zoneName.replace(/_/g, ' '), |
|
|
|
offset: `UTC${tz.format('Z')}`, |
|
|
|
nOffset: tz.utcOffset() |
|
|
|
}; |
|
|
|
}); |
|
|
|
}), |
|
|
|
tap((zones) => { |
|
|
|
timezones = zones; |
|
|
|
}) |
|
|
|
); |
|
|
|
export function getTimezones(): TimezoneInfo[] { |
|
|
|
if (!timezones) { |
|
|
|
timezones = monentTz.tz.names().map((zoneName) => { |
|
|
|
const tz = monentTz.tz(zoneName); |
|
|
|
return { |
|
|
|
id: zoneName, |
|
|
|
name: zoneName.replace(/_/g, ' '), |
|
|
|
offset: `UTC${tz.format('Z')}`, |
|
|
|
nOffset: tz.utcOffset() |
|
|
|
}; |
|
|
|
}); |
|
|
|
} |
|
|
|
return timezones; |
|
|
|
} |
|
|
|
|
|
|
|
export function getTimezoneInfo(timezoneId: string, defaultTimezoneId?: string, userTimezoneByDefault?: boolean): Observable<TimezoneInfo> { |
|
|
|
return getTimezones().pipe( |
|
|
|
mergeMap((timezoneList) => { |
|
|
|
let foundTimezone = timezoneList.find(timezoneInfo => timezoneInfo.id === timezoneId); |
|
|
|
if (!foundTimezone) { |
|
|
|
if (userTimezoneByDefault) { |
|
|
|
return getDefaultTimezone().pipe( |
|
|
|
map((userTimezone) => { |
|
|
|
return timezoneList.find(timezoneInfo => timezoneInfo.id === userTimezone); |
|
|
|
}) |
|
|
|
); |
|
|
|
} else if (defaultTimezoneId) { |
|
|
|
foundTimezone = timezoneList.find(timezoneInfo => timezoneInfo.id === defaultTimezoneId); |
|
|
|
} |
|
|
|
} |
|
|
|
return of(foundTimezone); |
|
|
|
}) |
|
|
|
); |
|
|
|
export function getTimezoneInfo(timezoneId: string, defaultTimezoneId?: string, userTimezoneByDefault?: boolean): TimezoneInfo { |
|
|
|
const timezoneList = getTimezones(); |
|
|
|
let foundTimezone = timezoneId ? timezoneList.find(timezoneInfo => timezoneInfo.id === timezoneId) : null; |
|
|
|
if (!foundTimezone) { |
|
|
|
if (userTimezoneByDefault) { |
|
|
|
const userTimezone = getDefaultTimezone(); |
|
|
|
foundTimezone = timezoneList.find(timezoneInfo => timezoneInfo.id === userTimezone); |
|
|
|
} else if (defaultTimezoneId) { |
|
|
|
foundTimezone = timezoneList.find(timezoneInfo => timezoneInfo.id === defaultTimezoneId); |
|
|
|
} |
|
|
|
} |
|
|
|
return foundTimezone; |
|
|
|
} |
|
|
|
|
|
|
|
export function getDefaultTimezone(): Observable<string> { |
|
|
|
if (defaultTimezone) { |
|
|
|
return of(defaultTimezone); |
|
|
|
export function getDefaultTimezone(): string { |
|
|
|
if (!defaultTimezone) { |
|
|
|
defaultTimezone = monentTz.tz.guess(); |
|
|
|
} |
|
|
|
return defaultTimezone; |
|
|
|
} |
|
|
|
|
|
|
|
export function getCurrentTime(tz?: string): moment_.Moment { |
|
|
|
if (tz) { |
|
|
|
return moment().tz(tz); |
|
|
|
} else { |
|
|
|
return from(import('moment-timezone')).pipe( |
|
|
|
map((monentTz) => { |
|
|
|
return monentTz.tz.guess(); |
|
|
|
}), |
|
|
|
tap((zone) => { |
|
|
|
defaultTimezone = zone; |
|
|
|
}) |
|
|
|
); |
|
|
|
return moment(); |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
export function getTimezone(tz: string): moment_.Moment { |
|
|
|
return moment.tz(tz); |
|
|
|
} |
|
|
|
|
Igor Kulikov
5 years ago