@c8y/ngx-components
Version:
Angular modules for Cumulocity IoT applications
240 lines • 43.9 kB
JavaScript
import { Component, Input, ViewChild } from '@angular/core';
import { AlarmService } from '@c8y/client';
import { AlarmRealtimeService, AlarmWithChildrenRealtimeService, AlertService, DashboardChildComponent, DismissAlertStrategy, DynamicComponentAlert, gettext, globalAutoRefreshLoading, WidgetGlobalAutoRefreshService } from '@c8y/ngx-components';
import { AlarmsViewService } from '@c8y/ngx-components/alarms';
import { isEmpty, isEqual } from 'lodash-es';
import { BehaviorSubject, Subject } from 'rxjs';
import { skip, takeUntil, tap } from 'rxjs/operators';
import { ASSET_ALARMS_WIDGET_ID, RECENT_ALARMS_WIDGET_ID } from '../alarm-list-widget.model';
import { AlarmWidgetService } from '../alarm-widget.service';
import { AlarmWidgetAlarmsReloadComponent } from '../alarm-widget-alarms-reload.component';
import * as i0 from "@angular/core";
import * as i1 from "../alarm-widget.service";
import * as i2 from "@c8y/ngx-components";
import * as i3 from "@c8y/client";
import * as i4 from "@c8y/ngx-components/alarms";
import * as i5 from "@angular/common";
import * as i6 from "../alarm-widget-alarms-reload.component";
/**
* To ensure backward compatibility, legacy widgets will be converted to the new implementation.
*/
export class AlarmListWidgetComponent {
constructor(alarmWidgetService, alarmRealtimeService, alarmService, alarmsViewService, alarmWithChildrenRealtimeService, dashboardChild, alertService, widgetGlobalAutoRefresh) {
this.alarmWidgetService = alarmWidgetService;
this.alarmRealtimeService = alarmRealtimeService;
this.alarmService = alarmService;
this.alarmsViewService = alarmsViewService;
this.alarmWithChildrenRealtimeService = alarmWithChildrenRealtimeService;
this.dashboardChild = dashboardChild;
this.alertService = alertService;
this.widgetGlobalAutoRefresh = widgetGlobalAutoRefresh;
/**
* Represents current alarms.
*/
this.alarms$ = new BehaviorSubject(null);
/**
* Current isLoading state. Based on it next countdown cycle is being started.
*/
this.isLoading$ = new BehaviorSubject(true);
this.TIMEOUT_ERROR_TEXT = gettext('The request is taking longer than usual. We apologize for the inconvenience.');
this.SERVER_ERROR_TEXT = gettext('Server error occurred.');
this.unsubscribe$ = new Subject();
this.destroy$ = new Subject();
this.isDisabled = false;
this.isIntervalRefresh = this.alarmsViewService.isIntervalRefresh();
}
async ngOnInit() {
this.alerts.setAlertGroupDismissStrategy('warning', DismissAlertStrategy.TEMPORARY_OR_PERMANENT);
if (this.alarmWidgetService.isOldAlarmConfigStructure(this.config)) {
const mappedConfig = this.alarmWidgetService.mapToNewConfigStructure(this.config, this.isIntervalRefresh);
Object.assign(this.config, mappedConfig);
}
if (this.config.widgetInstanceGlobalAutoRefreshContext && !this.config.isRealtime) {
this.handleGlobalRefreshLoading();
}
const _config = this.dashboardChild['data']?.config;
const isLegacyWidgetWithoutConfiguration = isEmpty(_config) || isEqual(_config, { displaySettings: { globalAutoRefreshContext: true } });
if (isLegacyWidgetWithoutConfiguration) {
this.setLegacyRecentOrCriticalAlarmWidgetConfig();
}
this.updateWidgetRefreshMode();
this.refreshInterval = !!this.config?.refreshInterval && this.config?.refreshInterval;
await this.fetchAlarms();
}
ngAfterViewInit() {
if (!this.isIntervalRefresh && this.config.refreshOption === 'interval') {
this.handleRealtimeAlarms(this.config, this.alarmWidgetAlarmsReloadComp.isRealtimeToggleOn);
}
}
ngOnChanges(changes) {
if (changes?.config?.currentValue?.date) {
this.config.dateFilter = changes.config.currentValue.date;
}
}
ngOnDestroy() {
if (this.config.isRealtime) {
this.unsubscribe$.next();
this.unsubscribe$.complete();
}
this.destroy$.next();
this.destroy$.complete();
if (this.config.widgetInstanceGlobalAutoRefreshContext && this.isLoading$.value) {
this.widgetGlobalAutoRefresh.decrementLoading();
}
}
async fetchAlarms() {
this.updateDateFilter();
this.alarms$.next(await this.getAlarms());
}
async onDateFilterChange(event) {
this.config.dateFilter = event.selectedDates;
this.config.interval = event.interval;
await this.fetchAlarms();
}
handleRealTimeToggleChange(isRealtimeToggleOn) {
if (!isRealtimeToggleOn) {
this.unsubscribe$.next();
this.unsubscribe$.complete();
}
this.unsubscribe$ = new Subject();
this.handleRealtimeAlarms(this.config, isRealtimeToggleOn);
}
/**
* Updates the widget's date filter based on the currently selected interval.
* If the interval is set to last hour, we will configure the date filter to dynamically show alarms only from the last hour.
*/
updateDateFilter() {
if (this.config.interval === 'custom' || this.config.widgetInstanceGlobalTimeContext) {
return;
}
if (!this.config.interval) {
this.config.interval = 'none';
}
this.config.dateFilter = this.alarmsViewService.getDateTimeContextByInterval(this.config.interval);
}
/**
* Updates the widget's refresh mode based on the current configuration and the interval refresh setting.
* If the widget's 'isRealtime' configuration differs from the current global interval refresh setting (application options setting),
* the widget's mode is updated to either 'realtime' or 'interval'. In 'realtime' mode, the refresh interval is null,
* and in 'interval' mode, it is set to the default interval value.
*/
updateWidgetRefreshMode() {
const isRefreshTypeSwitched = !!this.config.isRealtime !== !this.isIntervalRefresh;
if (!isRefreshTypeSwitched) {
return;
}
this.config.isRealtime = !this.isIntervalRefresh;
if (this.config.isRealtime) {
// Switching widget to realtime mode
this.config.refreshInterval = null;
this.config.refreshOption = null;
this.config.widgetInstanceGlobalAutoRefreshContext = false;
this.config.isAutoRefreshEnabled = true;
}
else {
// Switching widget to interval mode
this.config.refreshInterval = this.alarmsViewService.DEFAULT_INTERVAL_VALUE;
this.config.refreshOption = this.alarmsViewService.DEFAULT_REFRESH_OPTION_VALUE;
this.config.widgetInstanceGlobalAutoRefreshContext = false;
}
}
async getAlarms() {
try {
this.isLoading$.next(true);
return await this.alarmService.list(this.alarmWidgetService.mapConfigToQueryFilter(this.config));
}
catch (error) {
this.alerts.addAlerts(new DynamicComponentAlert({
type: 'warning',
text: error?.name === 'TimeoutError'
? this.TIMEOUT_ERROR_TEXT
: error?.message ?? this.SERVER_ERROR_TEXT
}));
if (error?.res?.status === 403) {
this.isDisabled = true;
return;
}
this.alertService.addServerFailure(error);
}
finally {
this.isLoading$.next(false);
}
}
/**
* Handles the realtime updates of alarms based on the widget configuration.
* If a specific device is provided in the widget configuration, all alarms
* originating from that device and its children are filtered based on status, severity, and type.
* Otherwise, it processes all incoming alarms and filters them according to status, severity, and type,
* as specified in the widget configuration. If new alarms meet the specified criteria, it sets a flag
* to indicate the presence of new alarms.
*
* @param config - The configuration settings of the alarm list widget.
* @param isRealtimeToggleOn - A flag indicating whether the realtime toggle is on. If true, the alarm list will be refreshed.
* If false, the presence of new alarms will be displayed as "New Alarms" entry on widget refresh button, but the list won't be refreshed automatically.
*/
handleRealtimeAlarms(config, isRealtimeToggleOn) {
const callback = (data) => {
if (this.alarmWidgetService.filterAlarmsByStatusSeverityAndType(data, this.alarms$.value.data, config)) {
if (isRealtimeToggleOn) {
this.fetchAlarms();
this.alarmWidgetAlarmsReloadComp.isNewAlarmMessageCleared = true;
}
else {
this.alarmWidgetAlarmsReloadComp.isNewAlarmMessageCleared = false;
}
}
};
if (this.config.device) {
this.handleRealtime(this.alarmWithChildrenRealtimeService.onAll$.bind(this.alarmWithChildrenRealtimeService), callback);
}
else {
this.handleRealtime(this.alarmRealtimeService.onAll$.bind(this.alarmRealtimeService), callback);
}
}
/**
* Sets up a subscription to a realtime data stream. This function takes a subscriber function,
* which is used to subscribe to the data stream, and a callback function, which is called with each
* data update received from the stream.
*
* @param subscriberFn - A function that returns an observable stream of alarm data.
* @param callback - A function to be executed with each alarm data update.
*/
handleRealtime(subscriberFn, callback) {
subscriberFn(this.config.device?.id)
.pipe(tap(({ data }) => {
callback(data);
}), takeUntil(this.unsubscribe$))
.subscribe();
}
setLegacyRecentOrCriticalAlarmWidgetConfig() {
const widgetId = this.dashboardChild['data']?.componentId
? this.dashboardChild['data']?.componentId //property is used in cockpit dashboards
: this.dashboardChild['data']?.name; //property is used in device management dashboards
if (widgetId === RECENT_ALARMS_WIDGET_ID) {
const predefinedConfig = this.alarmWidgetService.getPredefinedConfiguration(this.isIntervalRefresh, RECENT_ALARMS_WIDGET_ID);
Object.assign(this.config, predefinedConfig);
return;
}
if (widgetId === ASSET_ALARMS_WIDGET_ID) {
const predefinedConfig = this.alarmWidgetService.getPredefinedConfiguration(this.isIntervalRefresh);
Object.assign(this.config, predefinedConfig);
}
}
handleGlobalRefreshLoading() {
this.isLoading$
.pipe(skip(1), globalAutoRefreshLoading(this.widgetGlobalAutoRefresh), takeUntil(this.destroy$))
.subscribe();
}
static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AlarmListWidgetComponent, deps: [{ token: i1.AlarmWidgetService }, { token: i2.AlarmRealtimeService }, { token: i3.AlarmService }, { token: i4.AlarmsViewService }, { token: i2.AlarmWithChildrenRealtimeService }, { token: i2.DashboardChildComponent }, { token: i2.AlertService }, { token: i2.WidgetGlobalAutoRefreshService }], target: i0.ɵɵFactoryTarget.Component }); }
static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: AlarmListWidgetComponent, selector: "c8y-alarm-list-widget", inputs: { config: "config" }, providers: [AlarmRealtimeService, AlarmWithChildrenRealtimeService], viewQueries: [{ propertyName: "alarmWidgetAlarmsReloadComp", first: true, predicate: AlarmWidgetAlarmsReloadComponent, descendants: true }], usesOnChanges: true, ngImport: i0, template: "<c8y-alarms-list\n #list\n [alarms]=\"alarms$ | async\"\n [navigationOptions]=\"{\n alwaysNavigateToAllAlarms: !config.device,\n allowNavigationToAlarmsView: true,\n includeClearedQueryParams: true,\n queryParamsHandling: ''\n }\"\n [isInitialLoading]=\"isLoading$ | async\"\n [hasPermissions]=\"!isDisabled\"\n>\n <c8y-alarms-date-filter\n *ngIf=\"config.displayDateSelection\"\n [updateQueryParams]=\"false\"\n [date]=\"this.config.dateFilter\"\n [DEFAULT_INTERVAL]=\"config.interval || 'none'\"\n (dateFilterChange)=\"onDateFilterChange($event)\"\n ></c8y-alarms-date-filter>\n <c8y-alarm-widget-alarms-reload\n class=\"d-contents\"\n [isIntervalRefresh]=\"isIntervalRefresh\"\n [refreshInterval]=\"refreshInterval\"\n [config]=\"config\"\n [isLoading]=\"isLoading$\"\n [isScrolling]=\"list.isScrolling\"\n [isRefreshDisabled]=\"isDisabled\"\n (onCountdownEnded)=\"fetchAlarms()\"\n (onRealTimeToggleChanged)=\"handleRealTimeToggleChange($event)\"\n ></c8y-alarm-widget-alarms-reload>\n</c8y-alarms-list>\n", dependencies: [{ kind: "component", type: i4.AlarmsListComponent, selector: "c8y-alarms-list", inputs: ["alarms", "hasPermissions", "typeFilters", "loadMoreMode", "navigationOptions", "isInitialLoading", "splitView"], outputs: ["onSelectedAlarm", "onScrollingStateChange"] }, { kind: "component", type: i4.AlarmsDateFilterComponent, selector: "c8y-alarms-date-filter", inputs: ["DEFAULT_INTERVAL", "updateQueryParams", "date"], outputs: ["dateFilterChange"] }, { kind: "directive", type: i5.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i6.AlarmWidgetAlarmsReloadComponent, selector: "c8y-alarm-widget-alarms-reload", inputs: ["isIntervalRefresh", "refreshInterval", "config", "isLoading", "isScrolling", "isRefreshDisabled"], outputs: ["onCountdownEnded", "onRealTimeToggleChanged"] }, { kind: "pipe", type: i5.AsyncPipe, name: "async" }] }); }
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AlarmListWidgetComponent, decorators: [{
type: Component,
args: [{ selector: 'c8y-alarm-list-widget', providers: [AlarmRealtimeService, AlarmWithChildrenRealtimeService], template: "<c8y-alarms-list\n #list\n [alarms]=\"alarms$ | async\"\n [navigationOptions]=\"{\n alwaysNavigateToAllAlarms: !config.device,\n allowNavigationToAlarmsView: true,\n includeClearedQueryParams: true,\n queryParamsHandling: ''\n }\"\n [isInitialLoading]=\"isLoading$ | async\"\n [hasPermissions]=\"!isDisabled\"\n>\n <c8y-alarms-date-filter\n *ngIf=\"config.displayDateSelection\"\n [updateQueryParams]=\"false\"\n [date]=\"this.config.dateFilter\"\n [DEFAULT_INTERVAL]=\"config.interval || 'none'\"\n (dateFilterChange)=\"onDateFilterChange($event)\"\n ></c8y-alarms-date-filter>\n <c8y-alarm-widget-alarms-reload\n class=\"d-contents\"\n [isIntervalRefresh]=\"isIntervalRefresh\"\n [refreshInterval]=\"refreshInterval\"\n [config]=\"config\"\n [isLoading]=\"isLoading$\"\n [isScrolling]=\"list.isScrolling\"\n [isRefreshDisabled]=\"isDisabled\"\n (onCountdownEnded)=\"fetchAlarms()\"\n (onRealTimeToggleChanged)=\"handleRealTimeToggleChange($event)\"\n ></c8y-alarm-widget-alarms-reload>\n</c8y-alarms-list>\n" }]
}], ctorParameters: () => [{ type: i1.AlarmWidgetService }, { type: i2.AlarmRealtimeService }, { type: i3.AlarmService }, { type: i4.AlarmsViewService }, { type: i2.AlarmWithChildrenRealtimeService }, { type: i2.DashboardChildComponent }, { type: i2.AlertService }, { type: i2.WidgetGlobalAutoRefreshService }], propDecorators: { config: [{
type: Input
}], alarmWidgetAlarmsReloadComp: [{
type: ViewChild,
args: [AlarmWidgetAlarmsReloadComponent]
}] } });
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"alarm-list-widget.component.js","sourceRoot":"","sources":["../../../../../../widgets/implementations/alarms/alarm-list-widget-view/alarm-list-widget.component.ts","../../../../../../widgets/implementations/alarms/alarm-list-widget-view/alarm-list-widget.component.html"],"names":[],"mappings":"AAAA,OAAO,EAEL,SAAS,EACT,KAAK,EAIL,SAAS,EACV,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,YAAY,EAAgC,MAAM,aAAa,CAAC;AACzE,OAAO,EACL,oBAAoB,EACpB,gCAAgC,EAChC,YAAY,EACZ,uBAAuB,EACvB,oBAAoB,EAEpB,qBAAqB,EAErB,OAAO,EACP,wBAAwB,EACxB,8BAA8B,EAC/B,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAC/D,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAC7C,OAAO,EAAE,eAAe,EAAc,OAAO,EAAE,MAAM,MAAM,CAAC;AAC5D,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAC;AACtD,OAAO,EACL,sBAAsB,EAEtB,uBAAuB,EACxB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,EAAE,gCAAgC,EAAE,MAAM,yCAAyC,CAAC;;;;;;;;AAG3F;;GAEG;AAMH,MAAM,OAAO,wBAAwB;IAoCnC,YACU,kBAAsC,EACtC,oBAA0C,EAC1C,YAA0B,EAC1B,iBAAoC,EACpC,gCAAkE,EAClE,cAAuC,EACvC,YAA0B,EAC1B,uBAAuD;QAPvD,uBAAkB,GAAlB,kBAAkB,CAAoB;QACtC,yBAAoB,GAApB,oBAAoB,CAAsB;QAC1C,iBAAY,GAAZ,YAAY,CAAc;QAC1B,sBAAiB,GAAjB,iBAAiB,CAAmB;QACpC,qCAAgC,GAAhC,gCAAgC,CAAkC;QAClE,mBAAc,GAAd,cAAc,CAAyB;QACvC,iBAAY,GAAZ,YAAY,CAAc;QAC1B,4BAAuB,GAAvB,uBAAuB,CAAgC;QArCjE;;WAEG;QACH,YAAO,GAAgD,IAAI,eAAe,CAAC,IAAI,CAAC,CAAC;QACjF;;WAEG;QACH,eAAU,GAA6B,IAAI,eAAe,CAAC,IAAI,CAAC,CAAC;QAczD,uBAAkB,GAAG,OAAO,CAClC,8EAA8E,CAC/E,CAAC;QACM,sBAAiB,GAAG,OAAO,CAAC,wBAAwB,CAAC,CAAC;QACtD,iBAAY,GAAG,IAAI,OAAO,EAAQ,CAAC;QACnC,aAAQ,GAAkB,IAAI,OAAO,EAAE,CAAC;QAChD,eAAU,GAAG,KAAK,CAAC;QAYjB,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC,iBAAiB,CAAC,iBAAiB,EAAE,CAAC;IACtE,CAAC;IAED,KAAK,CAAC,QAAQ;QACZ,IAAI,CAAC,MAAM,CAAC,4BAA4B,CACtC,SAAS,EACT,oBAAoB,CAAC,sBAAsB,CAC5C,CAAC;QAEF,IAAI,IAAI,CAAC,kBAAkB,CAAC,yBAAyB,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC;YACnE,MAAM,YAAY,GAAG,IAAI,CAAC,kBAAkB,CAAC,uBAAuB,CAClE,IAAI,CAAC,MAAM,EACX,IAAI,CAAC,iBAAiB,CACvB,CAAC;YACF,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;QAC3C,CAAC;QAED,IAAI,IAAI,CAAC,MAAM,CAAC,sCAAsC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC;YAClF,IAAI,CAAC,0BAA0B,EAAE,CAAC;QACpC,CAAC;QACD,MAAM,OAAO,GAAG,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;QACpD,MAAM,kCAAkC,GACtC,OAAO,CAAC,OAAO,CAAC,IAAI,OAAO,CAAC,OAAO,EAAE,EAAE,eAAe,EAAE,EAAE,wBAAwB,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC;QAEhG,IAAI,kCAAkC,EAAE,CAAC;YACvC,IAAI,CAAC,0CAA0C,EAAE,CAAC;QACpD,CAAC;QAED,IAAI,CAAC,uBAAuB,EAAE,CAAC;QAC/B,IAAI,CAAC,eAAe,GAAG,CAAC,CAAC,IAAI,CAAC,MAAM,EAAE,eAAe,IAAI,IAAI,CAAC,MAAM,EAAE,eAAe,CAAC;QACtF,MAAM,IAAI,CAAC,WAAW,EAAE,CAAC;IAC3B,CAAC;IAED,eAAe;QACb,IAAI,CAAC,IAAI,CAAC,iBAAiB,IAAI,IAAI,CAAC,MAAM,CAAC,aAAa,KAAK,UAAU,EAAE,CAAC;YACxE,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,2BAA2B,CAAC,kBAAkB,CAAC,CAAC;QAC9F,CAAC;IACH,CAAC;IAED,WAAW,CAAC,OAAsB;QAChC,IAAI,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,IAAI,EAAE,CAAC;YACxC,IAAI,CAAC,MAAM,CAAC,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC,YAAY,CAAC,IAAI,CAAC;QAC5D,CAAC;IACH,CAAC;IAED,WAAW;QACT,IAAI,IAAI,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC;YAC3B,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,CAAC;YACzB,IAAI,CAAC,YAAY,CAAC,QAAQ,EAAE,CAAC;QAC/B,CAAC;QAED,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC;QACrB,IAAI,CAAC,QAAQ,CAAC,QAAQ,EAAE,CAAC;QAEzB,IAAI,IAAI,CAAC,MAAM,CAAC,sCAAsC,IAAI,IAAI,CAAC,UAAU,CAAC,KAAK,EAAE,CAAC;YAChF,IAAI,CAAC,uBAAuB,CAAC,gBAAgB,EAAE,CAAC;QAClD,CAAC;IACH,CAAC;IAED,KAAK,CAAC,WAAW;QACf,IAAI,CAAC,gBAAgB,EAAE,CAAC;QACxB,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM,IAAI,CAAC,SAAS,EAAE,CAAC,CAAC;IAC5C,CAAC;IAED,KAAK,CAAC,kBAAkB,CAAC,KAGxB;QACC,IAAI,CAAC,MAAM,CAAC,UAAU,GAAG,KAAK,CAAC,aAAa,CAAC;QAC7C,IAAI,CAAC,MAAM,CAAC,QAAQ,GAAG,KAAK,CAAC,QAAQ,CAAC;QACtC,MAAM,IAAI,CAAC,WAAW,EAAE,CAAC;IAC3B,CAAC;IAED,0BAA0B,CAAC,kBAA2B;QACpD,IAAI,CAAC,kBAAkB,EAAE,CAAC;YACxB,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,CAAC;YACzB,IAAI,CAAC,YAAY,CAAC,QAAQ,EAAE,CAAC;QAC/B,CAAC;QAED,IAAI,CAAC,YAAY,GAAG,IAAI,OAAO,EAAE,CAAC;QAClC,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAC;IAC7D,CAAC;IAED;;;OAGG;IACK,gBAAgB;QACtB,IAAI,IAAI,CAAC,MAAM,CAAC,QAAQ,KAAK,QAAQ,IAAI,IAAI,CAAC,MAAM,CAAC,+BAA+B,EAAE,CAAC;YACrF,OAAO;QACT,CAAC;QAED,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC;YAC1B,IAAI,CAAC,MAAM,CAAC,QAAQ,GAAG,MAAM,CAAC;QAChC,CAAC;QAED,IAAI,CAAC,MAAM,CAAC,UAAU,GAAG,IAAI,CAAC,iBAAiB,CAAC,4BAA4B,CAC1E,IAAI,CAAC,MAAM,CAAC,QAAQ,CACrB,CAAC;IACJ,CAAC;IAED;;;;;OAKG;IACK,uBAAuB;QAC7B,MAAM,qBAAqB,GAAG,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,UAAU,KAAK,CAAC,IAAI,CAAC,iBAAiB,CAAC;QACnF,IAAI,CAAC,qBAAqB,EAAE,CAAC;YAC3B,OAAO;QACT,CAAC;QAED,IAAI,CAAC,MAAM,CAAC,UAAU,GAAG,CAAC,IAAI,CAAC,iBAAiB,CAAC;QAEjD,IAAI,IAAI,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC;YAC3B,oCAAoC;YACpC,IAAI,CAAC,MAAM,CAAC,eAAe,GAAG,IAAI,CAAC;YACnC,IAAI,CAAC,MAAM,CAAC,aAAa,GAAG,IAAI,CAAC;YACjC,IAAI,CAAC,MAAM,CAAC,sCAAsC,GAAG,KAAK,CAAC;YAC3D,IAAI,CAAC,MAAM,CAAC,oBAAoB,GAAG,IAAI,CAAC;QAC1C,CAAC;aAAM,CAAC;YACN,oCAAoC;YACpC,IAAI,CAAC,MAAM,CAAC,eAAe,GAAG,IAAI,CAAC,iBAAiB,CAAC,sBAAsB,CAAC;YAC5E,IAAI,CAAC,MAAM,CAAC,aAAa,GAAG,IAAI,CAAC,iBAAiB,CAAC,4BAA4B,CAAC;YAChF,IAAI,CAAC,MAAM,CAAC,sCAAsC,GAAG,KAAK,CAAC;QAC7D,CAAC;IACH,CAAC;IAEO,KAAK,CAAC,SAAS;QACrB,IAAI,CAAC;YACH,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YAC3B,OAAO,MAAM,IAAI,CAAC,YAAY,CAAC,IAAI,CACjC,IAAI,CAAC,kBAAkB,CAAC,sBAAsB,CAAC,IAAI,CAAC,MAAM,CAAC,CAC5D,CAAC;QACJ,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,CAAC,MAAM,CAAC,SAAS,CACnB,IAAI,qBAAqB,CAAC;gBACxB,IAAI,EAAE,SAAS;gBACf,IAAI,EACF,KAAK,EAAE,IAAI,KAAK,cAAc;oBAC5B,CAAC,CAAC,IAAI,CAAC,kBAAkB;oBACzB,CAAC,CAAC,KAAK,EAAE,OAAO,IAAI,IAAI,CAAC,iBAAiB;aAC/C,CAAC,CACH,CAAC;YACF,IAAI,KAAK,EAAE,GAAG,EAAE,MAAM,KAAK,GAAG,EAAE,CAAC;gBAC/B,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;gBACvB,OAAO;YACT,CAAC;YACD,IAAI,CAAC,YAAY,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC;QAC5C,CAAC;gBAAS,CAAC;YACT,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAC9B,CAAC;IACH,CAAC;IAED;;;;;;;;;;;OAWG;IACK,oBAAoB,CAAC,MAA6B,EAAE,kBAA2B;QACrF,MAAM,QAAQ,GAAG,CAAC,IAAqB,EAAE,EAAE;YACzC,IACE,IAAI,CAAC,kBAAkB,CAAC,mCAAmC,CACzD,IAAI,EACJ,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,EACvB,MAAM,CACP,EACD,CAAC;gBACD,IAAI,kBAAkB,EAAE,CAAC;oBACvB,IAAI,CAAC,WAAW,EAAE,CAAC;oBACnB,IAAI,CAAC,2BAA2B,CAAC,wBAAwB,GAAG,IAAI,CAAC;gBACnE,CAAC;qBAAM,CAAC;oBACN,IAAI,CAAC,2BAA2B,CAAC,wBAAwB,GAAG,KAAK,CAAC;gBACpE,CAAC;YACH,CAAC;QACH,CAAC,CAAC;QAEF,IAAI,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC;YACvB,IAAI,CAAC,cAAc,CACjB,IAAI,CAAC,gCAAgC,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,gCAAgC,CAAC,EACxF,QAAQ,CACT,CAAC;QACJ,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,cAAc,CACjB,IAAI,CAAC,oBAAoB,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,oBAAoB,CAAC,EAChE,QAAQ,CACT,CAAC;QACJ,CAAC;IACH,CAAC;IAED;;;;;;;OAOG;IACK,cAAc,CACpB,YAA0D,EAC1D,QAAgC;QAEhC,YAAY,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,EAAE,CAAC;aACjC,IAAI,CACH,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE;YACf,QAAQ,CAAC,IAAI,CAAC,CAAC;QACjB,CAAC,CAAC,EACF,SAAS,CAAC,IAAI,CAAC,YAAY,CAAC,CAC7B;aACA,SAAS,EAAE,CAAC;IACjB,CAAC;IAEO,0CAA0C;QAChD,MAAM,QAAQ,GAAG,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,EAAE,WAAW;YACvD,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,EAAE,WAAW,CAAC,wCAAwC;YACnF,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,EAAE,IAAI,CAAC,CAAC,kDAAkD;QAEzF,IAAI,QAAQ,KAAK,uBAAuB,EAAE,CAAC;YACzC,MAAM,gBAAgB,GAAG,IAAI,CAAC,kBAAkB,CAAC,0BAA0B,CACzE,IAAI,CAAC,iBAAiB,EACtB,uBAAuB,CACxB,CAAC;YACF,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;YAE7C,OAAO;QACT,CAAC;QAED,IAAI,QAAQ,KAAK,sBAAsB,EAAE,CAAC;YACxC,MAAM,gBAAgB,GAAG,IAAI,CAAC,kBAAkB,CAAC,0BAA0B,CACzE,IAAI,CAAC,iBAAiB,CACvB,CAAC;YACF,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;QAC/C,CAAC;IACH,CAAC;IAEO,0BAA0B;QAChC,IAAI,CAAC,UAAU;aACZ,IAAI,CACH,IAAI,CAAC,CAAC,CAAC,EACP,wBAAwB,CAAC,IAAI,CAAC,uBAAuB,CAAC,EACtD,SAAS,CAAC,IAAI,CAAC,QAAQ,CAAC,CACzB;aACA,SAAS,EAAE,CAAC;IACjB,CAAC;+GAzSU,wBAAwB;mGAAxB,wBAAwB,8EAFxB,CAAC,oBAAoB,EAAE,gCAAgC,CAAC,uFA0BxD,gCAAgC,qECpE7C,mjCA+BA;;4FDaa,wBAAwB;kBALpC,SAAS;+BACE,uBAAuB,aAEtB,CAAC,oBAAoB,EAAE,gCAAgC,CAAC;kVAQ1D,MAAM;sBAAd,KAAK;gBAmBN,2BAA2B;sBAD1B,SAAS;uBAAC,gCAAgC","sourcesContent":["import {\n  AfterViewInit,\n  Component,\n  Input,\n  OnDestroy,\n  OnInit,\n  SimpleChanges,\n  ViewChild\n} from '@angular/core';\nimport { AlarmService, IAlarm, IResult, IResultList } from '@c8y/client';\nimport {\n  AlarmRealtimeService,\n  AlarmWithChildrenRealtimeService,\n  AlertService,\n  DashboardChildComponent,\n  DismissAlertStrategy,\n  DynamicComponent,\n  DynamicComponentAlert,\n  DynamicComponentAlertAggregator,\n  gettext,\n  globalAutoRefreshLoading,\n  WidgetGlobalAutoRefreshService\n} from '@c8y/ngx-components';\nimport { AlarmsViewService } from '@c8y/ngx-components/alarms';\nimport { isEmpty, isEqual } from 'lodash-es';\nimport { BehaviorSubject, Observable, Subject } from 'rxjs';\nimport { skip, takeUntil, tap } from 'rxjs/operators';\nimport {\n  ASSET_ALARMS_WIDGET_ID,\n  AlarmListWidgetConfig,\n  RECENT_ALARMS_WIDGET_ID\n} from '../alarm-list-widget.model';\nimport { AlarmWidgetService } from '../alarm-widget.service';\nimport { AlarmWidgetAlarmsReloadComponent } from '../alarm-widget-alarms-reload.component';\nimport { Interval } from '@c8y/ngx-components/interval-picker';\n\n/**\n * To ensure backward compatibility, legacy widgets will be converted to the new implementation.\n */\n@Component({\n  selector: 'c8y-alarm-list-widget',\n  templateUrl: './alarm-list-widget.component.html',\n  providers: [AlarmRealtimeService, AlarmWithChildrenRealtimeService]\n})\nexport class AlarmListWidgetComponent\n  implements OnInit, AfterViewInit, OnDestroy, DynamicComponent\n{\n  /**\n   *  Alarm widget config.\n   */\n  @Input() config: AlarmListWidgetConfig;\n  /**\n   * Represents current alarms.\n   */\n  alarms$: BehaviorSubject<IResultList<IAlarm> | null> = new BehaviorSubject(null);\n  /**\n   * Current isLoading state. Based on it next countdown cycle is being started.\n   */\n  isLoading$: BehaviorSubject<boolean> = new BehaviorSubject(true);\n  /**\n   * State of this boolean depends on an Application Options \"alarmsRefreshType\" setting.\n   */\n  isIntervalRefresh: boolean;\n  /**\n   * Current refresh interval set in a widget config.\n   */\n  refreshInterval: number;\n\n  @ViewChild(AlarmWidgetAlarmsReloadComponent)\n  alarmWidgetAlarmsReloadComp: AlarmWidgetAlarmsReloadComponent;\n  alerts: DynamicComponentAlertAggregator;\n\n  private TIMEOUT_ERROR_TEXT = gettext(\n    'The request is taking longer than usual. We apologize for the inconvenience.'\n  );\n  private SERVER_ERROR_TEXT = gettext('Server error occurred.');\n  private unsubscribe$ = new Subject<void>();\n  private destroy$: Subject<void> = new Subject();\n  isDisabled = false;\n\n  constructor(\n    private alarmWidgetService: AlarmWidgetService,\n    private alarmRealtimeService: AlarmRealtimeService,\n    private alarmService: AlarmService,\n    private alarmsViewService: AlarmsViewService,\n    private alarmWithChildrenRealtimeService: AlarmWithChildrenRealtimeService,\n    private dashboardChild: DashboardChildComponent,\n    private alertService: AlertService,\n    private widgetGlobalAutoRefresh: WidgetGlobalAutoRefreshService\n  ) {\n    this.isIntervalRefresh = this.alarmsViewService.isIntervalRefresh();\n  }\n\n  async ngOnInit(): Promise<void> {\n    this.alerts.setAlertGroupDismissStrategy(\n      'warning',\n      DismissAlertStrategy.TEMPORARY_OR_PERMANENT\n    );\n\n    if (this.alarmWidgetService.isOldAlarmConfigStructure(this.config)) {\n      const mappedConfig = this.alarmWidgetService.mapToNewConfigStructure(\n        this.config,\n        this.isIntervalRefresh\n      );\n      Object.assign(this.config, mappedConfig);\n    }\n\n    if (this.config.widgetInstanceGlobalAutoRefreshContext && !this.config.isRealtime) {\n      this.handleGlobalRefreshLoading();\n    }\n    const _config = this.dashboardChild['data']?.config;\n    const isLegacyWidgetWithoutConfiguration =\n      isEmpty(_config) || isEqual(_config, { displaySettings: { globalAutoRefreshContext: true } });\n\n    if (isLegacyWidgetWithoutConfiguration) {\n      this.setLegacyRecentOrCriticalAlarmWidgetConfig();\n    }\n\n    this.updateWidgetRefreshMode();\n    this.refreshInterval = !!this.config?.refreshInterval && this.config?.refreshInterval;\n    await this.fetchAlarms();\n  }\n\n  ngAfterViewInit(): void {\n    if (!this.isIntervalRefresh && this.config.refreshOption === 'interval') {\n      this.handleRealtimeAlarms(this.config, this.alarmWidgetAlarmsReloadComp.isRealtimeToggleOn);\n    }\n  }\n\n  ngOnChanges(changes: SimpleChanges): void {\n    if (changes?.config?.currentValue?.date) {\n      this.config.dateFilter = changes.config.currentValue.date;\n    }\n  }\n\n  ngOnDestroy(): void {\n    if (this.config.isRealtime) {\n      this.unsubscribe$.next();\n      this.unsubscribe$.complete();\n    }\n\n    this.destroy$.next();\n    this.destroy$.complete();\n\n    if (this.config.widgetInstanceGlobalAutoRefreshContext && this.isLoading$.value) {\n      this.widgetGlobalAutoRefresh.decrementLoading();\n    }\n  }\n\n  async fetchAlarms(): Promise<void> {\n    this.updateDateFilter();\n    this.alarms$.next(await this.getAlarms());\n  }\n\n  async onDateFilterChange(event: {\n    selectedDates: [Date, Date];\n    interval: Interval['id'];\n  }): Promise<void> {\n    this.config.dateFilter = event.selectedDates;\n    this.config.interval = event.interval;\n    await this.fetchAlarms();\n  }\n\n  handleRealTimeToggleChange(isRealtimeToggleOn: boolean): void {\n    if (!isRealtimeToggleOn) {\n      this.unsubscribe$.next();\n      this.unsubscribe$.complete();\n    }\n\n    this.unsubscribe$ = new Subject();\n    this.handleRealtimeAlarms(this.config, isRealtimeToggleOn);\n  }\n\n  /**\n   * Updates the widget's date filter based on the currently selected interval.\n   * If the interval is set to last hour, we will configure the date filter to dynamically show alarms only from the last hour.\n   */\n  private updateDateFilter(): void {\n    if (this.config.interval === 'custom' || this.config.widgetInstanceGlobalTimeContext) {\n      return;\n    }\n\n    if (!this.config.interval) {\n      this.config.interval = 'none';\n    }\n\n    this.config.dateFilter = this.alarmsViewService.getDateTimeContextByInterval(\n      this.config.interval\n    );\n  }\n\n  /**\n   * Updates the widget's refresh mode based on the current configuration and the interval refresh setting.\n   * If the widget's 'isRealtime' configuration differs from the current global interval refresh setting (application options setting),\n   * the widget's mode is updated to either 'realtime' or 'interval'. In 'realtime' mode, the refresh interval is null,\n   * and in 'interval' mode, it is set to the default interval value.\n   */\n  private updateWidgetRefreshMode(): void {\n    const isRefreshTypeSwitched = !!this.config.isRealtime !== !this.isIntervalRefresh;\n    if (!isRefreshTypeSwitched) {\n      return;\n    }\n\n    this.config.isRealtime = !this.isIntervalRefresh;\n\n    if (this.config.isRealtime) {\n      // Switching widget to realtime mode\n      this.config.refreshInterval = null;\n      this.config.refreshOption = null;\n      this.config.widgetInstanceGlobalAutoRefreshContext = false;\n      this.config.isAutoRefreshEnabled = true;\n    } else {\n      // Switching widget to interval mode\n      this.config.refreshInterval = this.alarmsViewService.DEFAULT_INTERVAL_VALUE;\n      this.config.refreshOption = this.alarmsViewService.DEFAULT_REFRESH_OPTION_VALUE;\n      this.config.widgetInstanceGlobalAutoRefreshContext = false;\n    }\n  }\n\n  private async getAlarms(): Promise<IResultList<IAlarm>> {\n    try {\n      this.isLoading$.next(true);\n      return await this.alarmService.list(\n        this.alarmWidgetService.mapConfigToQueryFilter(this.config)\n      );\n    } catch (error) {\n      this.alerts.addAlerts(\n        new DynamicComponentAlert({\n          type: 'warning',\n          text:\n            error?.name === 'TimeoutError'\n              ? this.TIMEOUT_ERROR_TEXT\n              : error?.message ?? this.SERVER_ERROR_TEXT\n        })\n      );\n      if (error?.res?.status === 403) {\n        this.isDisabled = true;\n        return;\n      }\n      this.alertService.addServerFailure(error);\n    } finally {\n      this.isLoading$.next(false);\n    }\n  }\n\n  /**\n   * Handles the realtime updates of alarms based on the widget configuration.\n   * If a specific device is provided in the widget configuration, all alarms\n   * originating from that device and its children are filtered based on status, severity, and type.\n   * Otherwise, it processes all incoming alarms and filters them according to status, severity, and type,\n   * as specified in the widget configuration. If new alarms meet the specified criteria, it sets a flag\n   * to indicate the presence of new alarms.\n   *\n   * @param config - The configuration settings of the alarm list widget.\n   * @param isRealtimeToggleOn - A flag indicating whether the realtime toggle is on. If true, the alarm list will be refreshed.\n   * If false, the presence of new alarms will be displayed as \"New Alarms\" entry on widget refresh button, but the list won't be refreshed automatically.\n   */\n  private handleRealtimeAlarms(config: AlarmListWidgetConfig, isRealtimeToggleOn: boolean): void {\n    const callback = (data: number | IAlarm) => {\n      if (\n        this.alarmWidgetService.filterAlarmsByStatusSeverityAndType(\n          data,\n          this.alarms$.value.data,\n          config\n        )\n      ) {\n        if (isRealtimeToggleOn) {\n          this.fetchAlarms();\n          this.alarmWidgetAlarmsReloadComp.isNewAlarmMessageCleared = true;\n        } else {\n          this.alarmWidgetAlarmsReloadComp.isNewAlarmMessageCleared = false;\n        }\n      }\n    };\n\n    if (this.config.device) {\n      this.handleRealtime(\n        this.alarmWithChildrenRealtimeService.onAll$.bind(this.alarmWithChildrenRealtimeService),\n        callback\n      );\n    } else {\n      this.handleRealtime(\n        this.alarmRealtimeService.onAll$.bind(this.alarmRealtimeService),\n        callback\n      );\n    }\n  }\n\n  /**\n   * Sets up a subscription to a realtime data stream. This function takes a subscriber function,\n   * which is used to subscribe to the data stream, and a callback function, which is called with each\n   * data update received from the stream.\n   *\n   * @param subscriberFn - A function that returns an observable stream of alarm data.\n   * @param callback - A function to be executed with each alarm data update.\n   */\n  private handleRealtime(\n    subscriberFn: (id?: string) => Observable<IResult<IAlarm>>,\n    callback: (data: IAlarm) => void\n  ): void {\n    subscriberFn(this.config.device?.id)\n      .pipe(\n        tap(({ data }) => {\n          callback(data);\n        }),\n        takeUntil(this.unsubscribe$)\n      )\n      .subscribe();\n  }\n\n  private setLegacyRecentOrCriticalAlarmWidgetConfig(): void {\n    const widgetId = this.dashboardChild['data']?.componentId\n      ? this.dashboardChild['data']?.componentId //property is used in cockpit dashboards\n      : this.dashboardChild['data']?.name; //property is used in device management dashboards\n\n    if (widgetId === RECENT_ALARMS_WIDGET_ID) {\n      const predefinedConfig = this.alarmWidgetService.getPredefinedConfiguration(\n        this.isIntervalRefresh,\n        RECENT_ALARMS_WIDGET_ID\n      );\n      Object.assign(this.config, predefinedConfig);\n\n      return;\n    }\n\n    if (widgetId === ASSET_ALARMS_WIDGET_ID) {\n      const predefinedConfig = this.alarmWidgetService.getPredefinedConfiguration(\n        this.isIntervalRefresh\n      );\n      Object.assign(this.config, predefinedConfig);\n    }\n  }\n\n  private handleGlobalRefreshLoading(): void {\n    this.isLoading$\n      .pipe(\n        skip(1),\n        globalAutoRefreshLoading(this.widgetGlobalAutoRefresh),\n        takeUntil(this.destroy$)\n      )\n      .subscribe();\n  }\n}\n","<c8y-alarms-list\n  #list\n  [alarms]=\"alarms$ | async\"\n  [navigationOptions]=\"{\n    alwaysNavigateToAllAlarms: !config.device,\n    allowNavigationToAlarmsView: true,\n    includeClearedQueryParams: true,\n    queryParamsHandling: ''\n  }\"\n  [isInitialLoading]=\"isLoading$ | async\"\n  [hasPermissions]=\"!isDisabled\"\n>\n  <c8y-alarms-date-filter\n    *ngIf=\"config.displayDateSelection\"\n    [updateQueryParams]=\"false\"\n    [date]=\"this.config.dateFilter\"\n    [DEFAULT_INTERVAL]=\"config.interval || 'none'\"\n    (dateFilterChange)=\"onDateFilterChange($event)\"\n  ></c8y-alarms-date-filter>\n  <c8y-alarm-widget-alarms-reload\n    class=\"d-contents\"\n    [isIntervalRefresh]=\"isIntervalRefresh\"\n    [refreshInterval]=\"refreshInterval\"\n    [config]=\"config\"\n    [isLoading]=\"isLoading$\"\n    [isScrolling]=\"list.isScrolling\"\n    [isRefreshDisabled]=\"isDisabled\"\n    (onCountdownEnded)=\"fetchAlarms()\"\n    (onRealTimeToggleChanged)=\"handleRealTimeToggleChange($event)\"\n  ></c8y-alarm-widget-alarms-reload>\n</c8y-alarms-list>\n"]}