@c8y/ngx-components
Version:
Angular modules for Cumulocity IoT applications
261 lines • 34.5 kB
JavaScript
import { Injectable } from '@angular/core';
import { ALARM_STATUS_LABELS, AlarmService, AlarmStatus, Severity } from '@c8y/client';
import { OptionsService, ViewContext, gettext } from '@c8y/ngx-components';
import { BehaviorSubject, Subject } from 'rxjs';
import { ALARMS_PATH, INTERVALS_EXTENDED } from './alarms.model';
import * as i0 from "@angular/core";
import * as i1 from "@c8y/client";
import * as i2 from "@c8y/ngx-components";
/**
* Service for managing and retrieving alarms data within the alarms view.
*
* The `AlarmsViewService` provides functionality to interact with alarms,
* including filtering, counting, and translation-related operations in an alarms view.
*
* This service relies on the `AlarmService` for fetching alarm data and the `OptionsService`
* for configuring alarms view options.
*/
export class AlarmsViewService {
constructor(alarmService, optionsService) {
this.alarmService = alarmService;
this.optionsService = optionsService;
this.ALARM_REFRESH_TYPE_KEY = 'alarmsRefreshType';
this.DEFAULT_INTERVAL_VALUE = 30_000;
this.DEFAULT_REFRESH_OPTION_VALUE = 'interval';
this.DEFAULT_INTERVAL_VALUES = [5_000, 10_000, 15_000, 30_000, 60_000];
this.REALTIME_UPDATE_ALARMS_MESSAGE = gettext('The list was updated, click to refresh.');
this.reloadAlarmsList$ = new Subject();
if (this.isIntervalRefresh()) {
this._isIntervalEnabled = new BehaviorSubject(true);
this.isIntervalEnabled$ = this._isIntervalEnabled.asObservable();
}
}
/**
* Emits a subject to initialize the alarms reloading.
*/
updateAlarmList() {
this.reloadAlarmsList$.next();
}
/**
* Retrieves a list of alarms filtered by specified severities and other optional query filters.
*
* @param severities an array of severities to filter the alarms.
* @param showCleared flag indicating whether to show cleared alarms. Defaults to false.
* @param selectedDates an array of two dates to filter alarms by creation and last update dates.
* @param filter additional query filters for retrieving alarms.
*
* @returns A promise that resolves to a list of alarms satisfying the specified filters.
*/
retrieveFilteredAlarms(severities, showCleared = false, selectedDates, filter) {
const severitiesQuery = this.getSeverityQueryParameter(severities);
const statusesQuery = this.getStatusQueryParameter(showCleared);
const _filter = {
pageSize: 50,
withTotalPages: true,
...(severitiesQuery && { severity: severitiesQuery }),
...(statusesQuery && { status: statusesQuery }),
...(selectedDates && {
lastUpdatedFrom: selectedDates[0].toISOString(),
createdTo: selectedDates[1].toISOString()
}),
...filter
};
return this.alarmService.list(_filter);
}
retrieveAlarmsByDate(dates) {
return this.alarmService.list({
lastUpdatedFrom: dates[0].toISOString(),
createdTo: dates[1].toISOString(),
pageSize: 50,
withTotalPages: true
});
}
/**
* Updates the state to enable or disable intervals.
* @param value - A boolean value to indicate whether to enable intervals.
*/
updateIntervalState(value) {
this._isIntervalEnabled?.next(value);
}
/**
* Fetches the count of alarms filtered by severity and clearance status.
*
* @param severity - The severity level to filter by (e.g., CRITICAL, MAJOR, etc.).
* @param showCleared - Whether or not to include cleared alarms in the count.
* @param filter - Additional filter criteria for alarms.
*
* @returns A promise that resolves to the number of alarms that match the filter criteria.
*
*/
async getAlarmsCountBySeverity(severity, showCleared, filter) {
const statusesQuery = this.getStatusQueryParameter(showCleared);
const _filter = {
...(severity && { severity: severity }),
...(statusesQuery && { status: statusesQuery }),
...filter
};
const { data } = await this.alarmService.count(_filter);
return data;
}
/**
* Retrieves the current alarms refresh type from the OptionsService
* and determines whether it is set to "interval".
*
* @returns `true` if the alarms refresh type is "interval," otherwise `false`.
*/
isIntervalRefresh() {
const value = this.optionsService.get(this.ALARM_REFRESH_TYPE_KEY, 'interval');
return value === 'interval';
}
/**
* Updates the list of selected severities based on the new severity filter.
*
* @param severityUpdates - The object representing the updates to each severity.
*
* @returns An array representing the updated selected severities.
*/
updateSelectedSeverities(severityUpdates) {
return Object.keys(severityUpdates)
.filter(key => severityUpdates[key])
.map(key => key.toUpperCase());
}
/**
* Clears all active alarms of the selected severities.
*
* This method clears all active alarms for the given list of severities by making bulk update calls. If no severities are selected, it defaults to using all available severities.
* It works by sending a series of update requests for each severity and returns a Promise that resolves with an object indicating if all alarms were resolved immediately.
*
* @param selectedSeverities An array of severities to be cleared. If not provided, all severities will be cleared.
* @param sourceId - Identifier for the source associated with the alarms to be cleared.
*
* @returns A Promise that resolves with an object with a flag `resolvedImmediately`. The flag is true if all alarms for all selected severities were cleared successfully; otherwise false.
*
* **Example**
* ```typescript
* const severitiesToClear: SeverityType[] = [Severity.MAJOR, Severity.MINOR];
*
* clearAllActiveAlarms(severitiesToClear).then(({ resolvedImmediately }) => {
* if (resolvedImmediately) {
* console.log('All selected alarms were cleared successfully.');
* } else {
* console.log('Some alarms could not be cleared.');
* }
* });
* ```
*
* **Note**
* - The method uses the `alarmService.updateBulk` for each severity to clear the active alarms.
* - It may fetch the `sourceId` based on the view (if applicable) and include it as a query parameter in the update calls.
* - The method returns immediately but the returned Promise needs to have a `then` or `catch` method call to handle the result or error respectively.
* - Uses `Promise.all` to wait for all update requests to complete before resolving the final result.
*/
async clearAllActiveAlarms(selectedSeverities, sourceId) {
const severitiesToUpdate = selectedSeverities || Severity;
const promises = Object.values(severitiesToUpdate).map((severity) => {
const commonParams = { resolved: false, severity };
const parameters = sourceId
? {
...commonParams,
source: sourceId,
withSourceAssets: true,
withSourceDevices: true
}
: commonParams;
return this.alarmService.updateBulk({ status: AlarmStatus.CLEARED }, parameters);
});
const responses = await Promise.all(promises);
return {
resolvedImmediately: responses.every(res => res)
};
}
/**
* Returns the correct link based on the provided context data.
* @param contextData The context the navigation was triggered from.
* @param alarm The alarm to navigate to.
* @returns A link to be used as an url navigation.
*/
getRouterLink(contextData, alarm) {
let detailUrl = `/${ALARMS_PATH}`;
if (alarm) {
detailUrl = `/${ALARMS_PATH}/${alarm.id}`;
}
if (!contextData) {
return detailUrl;
}
switch (contextData.context) {
case ViewContext.Device:
return `/device/${contextData.contextData.id}${detailUrl}`;
case ViewContext.Group:
return `/group/${contextData.contextData.id}${detailUrl}`;
case ViewContext.Simulators:
return `/simulators/${contextData.contextData.id}${detailUrl}`;
default:
return detailUrl;
}
}
/**
* Returns the correct array navigation.
* @param contextData The context the navigation was triggered from.
* @param alarm The alarm to navigate to.
* @returns A link to be used as a router.navigation.
*/
getRouterNavigationArray(contextData, alarm) {
return this.getRouterLink(contextData, alarm).split('/').filter(Boolean);
}
/**
* Returns the correct from and to dates based on the selected interval
* @param intervalId the selected interval. E.g. 'none', 'hours', 'custom' ...
* @returns The calculated date context based on the selected interval.
*/
getDateTimeContextByInterval(intervalId) {
const interval = INTERVALS_EXTENDED.find(({ id }) => id === intervalId);
if (interval.id === 'none') {
return [new Date(0), new Date()];
}
const dateTo = new Date();
const dateFrom = new Date(dateTo.valueOf() - interval.timespanInMs);
return [dateFrom, dateTo];
}
/**
* Creates a value for query parameter for filtering alarms by severity based on array of selected severities.
*
* @param severities - An array of alarm severity types to include in the filter.
* If the array is empty or undefined, no severity filter will be applied.
*
* @returns A comma-separated string of selected alarm severities,
* or null if no severities are provided.
*/
getSeverityQueryParameter(severities) {
if (!severities || severities.length === 0) {
return;
}
if (severities.length === Object.keys(Severity).length) {
return;
}
return severities.join(',');
}
/**
* Creates a value for query parameter for filtering alarms by statuses based on showCleared option.
*
* @param showCleared - A flag indicating whether to include cleared statuses.
* If true, all statuses, including 'CLEARED', will be included; if false, 'CLEARED' will be excluded.
*
* @returns A comma-separated string of alarm statuses.
*/
getStatusQueryParameter(showCleared) {
const statuses = Object.keys(ALARM_STATUS_LABELS);
const filteredStatuses = showCleared
? statuses
: statuses.filter(status => status !== 'CLEARED');
return filteredStatuses.join(',');
}
static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AlarmsViewService, deps: [{ token: i1.AlarmService }, { token: i2.OptionsService }], target: i0.ɵɵFactoryTarget.Injectable }); }
static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AlarmsViewService, providedIn: 'root' }); }
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AlarmsViewService, decorators: [{
type: Injectable,
args: [{
providedIn: 'root'
}]
}], ctorParameters: () => [{ type: i1.AlarmService }, { type: i2.OptionsService }] });
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"alarms-view.service.js","sourceRoot":"","sources":["../../../alarms/alarms-view.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport {\n  ALARM_STATUS_LABELS,\n  AlarmQueryFilter,\n  AlarmService,\n  AlarmStatus,\n  AlarmStatusType,\n  IAlarm,\n  IResultList,\n  Severity,\n  SeverityFilter,\n  SeverityType\n} from '@c8y/client';\nimport {\n  ApplicationOptions,\n  ContextData,\n  DateTimeContext,\n  OptionsService,\n  ViewContext,\n  gettext\n} from '@c8y/ngx-components';\nimport { BehaviorSubject, Observable, Subject } from 'rxjs';\nimport { ALARMS_PATH, INTERVALS_EXTENDED } from './alarms.model';\nimport { AlarmFilterInterval } from '@c8y/ngx-components/interval-picker';\n\n/**\n * Service for managing and retrieving alarms data within the alarms view.\n *\n * The `AlarmsViewService` provides functionality to interact with alarms,\n * including filtering, counting, and translation-related operations in an alarms view.\n *\n * This service relies on the `AlarmService` for fetching alarm data and the `OptionsService`\n * for configuring alarms view options.\n */\n@Injectable({\n  providedIn: 'root'\n})\nexport class AlarmsViewService {\n  readonly ALARM_REFRESH_TYPE_KEY: keyof ApplicationOptions = 'alarmsRefreshType';\n  readonly DEFAULT_INTERVAL_VALUE = 30_000;\n  readonly DEFAULT_REFRESH_OPTION_VALUE = 'interval';\n  readonly DEFAULT_INTERVAL_VALUES = [5_000, 10_000, 15_000, 30_000, 60_000];\n  readonly REALTIME_UPDATE_ALARMS_MESSAGE = gettext('The list was updated, click to refresh.');\n\n  isIntervalEnabled$: Observable<boolean>;\n  reloadAlarmsList$ = new Subject<void>();\n\n  private _isIntervalEnabled: BehaviorSubject<boolean>;\n\n  constructor(\n    private alarmService: AlarmService,\n    private optionsService: OptionsService\n  ) {\n    if (this.isIntervalRefresh()) {\n      this._isIntervalEnabled = new BehaviorSubject<boolean>(true);\n      this.isIntervalEnabled$ = this._isIntervalEnabled.asObservable();\n    }\n  }\n\n  /**\n   * Emits a subject to initialize the alarms reloading.\n   */\n  updateAlarmList(): void {\n    this.reloadAlarmsList$.next();\n  }\n\n  /**\n   * Retrieves a list of alarms filtered by specified severities and other optional query filters.\n   *\n   * @param severities an array of severities to filter the alarms.\n   * @param showCleared flag indicating whether to show cleared alarms. Defaults to false.\n   * @param selectedDates an array of two dates to filter alarms by creation and last update dates.\n   * @param filter additional query filters for retrieving alarms.\n   *\n   * @returns A promise that resolves to a list of alarms satisfying the specified filters.\n   */\n  retrieveFilteredAlarms(\n    severities: SeverityType[],\n    showCleared = false,\n    selectedDates?: [Date, Date],\n    filter?: AlarmQueryFilter\n  ): Promise<IResultList<IAlarm>> {\n    const severitiesQuery = this.getSeverityQueryParameter(severities);\n    const statusesQuery = this.getStatusQueryParameter(showCleared);\n\n    const _filter: AlarmQueryFilter = {\n      pageSize: 50,\n      withTotalPages: true,\n      ...(severitiesQuery && { severity: severitiesQuery }),\n      ...(statusesQuery && { status: statusesQuery }),\n      ...(selectedDates && {\n        lastUpdatedFrom: selectedDates[0].toISOString(),\n        createdTo: selectedDates[1].toISOString()\n      }),\n      ...filter\n    };\n    return this.alarmService.list(_filter);\n  }\n\n  retrieveAlarmsByDate(dates: DateTimeContext) {\n    return this.alarmService.list({\n      lastUpdatedFrom: dates[0].toISOString(),\n      createdTo: dates[1].toISOString(),\n      pageSize: 50,\n      withTotalPages: true\n    });\n  }\n\n  /**\n   * Updates the state to enable or disable intervals.\n   * @param value - A boolean value to indicate whether to enable intervals.\n   */\n  updateIntervalState(value: boolean): void {\n    this._isIntervalEnabled?.next(value);\n  }\n\n  /**\n   * Fetches the count of alarms filtered by severity and clearance status.\n   *\n   * @param severity - The severity level to filter by (e.g., CRITICAL, MAJOR, etc.).\n   * @param showCleared - Whether or not to include cleared alarms in the count.\n   * @param filter - Additional filter criteria for alarms.\n   *\n   * @returns A promise that resolves to the number of alarms that match the filter criteria.\n   *\n   */\n  async getAlarmsCountBySeverity(\n    severity: SeverityType,\n    showCleared: boolean,\n    filter?: AlarmQueryFilter\n  ): Promise<number> {\n    const statusesQuery = this.getStatusQueryParameter(showCleared);\n    const _filter: AlarmQueryFilter = {\n      ...(severity && { severity: severity }),\n      ...(statusesQuery && { status: statusesQuery }),\n      ...filter\n    };\n    const { data } = await this.alarmService.count(_filter);\n\n    return data;\n  }\n\n  /**\n   * Retrieves the current alarms refresh type from the OptionsService\n   * and determines whether it is set to \"interval\".\n   *\n   * @returns `true` if the alarms refresh type is \"interval,\" otherwise `false`.\n   */\n  isIntervalRefresh(): boolean {\n    const value = this.optionsService.get(this.ALARM_REFRESH_TYPE_KEY, 'interval');\n    return value === 'interval';\n  }\n\n  /**\n   * Updates the list of selected severities based on the new severity filter.\n   *\n   * @param severityUpdates - The object representing the updates to each severity.\n   *\n   * @returns An array representing the updated selected severities.\n   */\n  updateSelectedSeverities(severityUpdates: SeverityFilter): SeverityType[] {\n    return (Object.keys(severityUpdates) as SeverityType[])\n      .filter(key => severityUpdates[key])\n      .map(key => key.toUpperCase() as SeverityType);\n  }\n\n  /**\n   * Clears all active alarms of the selected severities.\n   *\n   * This method clears all active alarms for the given list of severities by making bulk update calls. If no severities are selected, it defaults to using all available severities.\n   * It works by sending a series of update requests for each severity and returns a Promise that resolves with an object indicating if all alarms were resolved immediately.\n   *\n   * @param selectedSeverities An array of severities to be cleared. If not provided, all severities will be cleared.\n   * @param sourceId - Identifier for the source associated with the alarms to be cleared.\n   *\n   * @returns A Promise that resolves with an object with a flag `resolvedImmediately`. The flag is true if all alarms for all selected severities were cleared successfully; otherwise false.\n   *\n   * **Example**\n   * ```typescript\n   * const severitiesToClear: SeverityType[] = [Severity.MAJOR, Severity.MINOR];\n   *\n   * clearAllActiveAlarms(severitiesToClear).then(({ resolvedImmediately }) => {\n   *   if (resolvedImmediately) {\n   *     console.log('All selected alarms were cleared successfully.');\n   *   } else {\n   *     console.log('Some alarms could not be cleared.');\n   *   }\n   * });\n   * ```\n   *\n   * **Note**\n   * - The method uses the `alarmService.updateBulk` for each severity to clear the active alarms.\n   * - It may fetch the `sourceId` based on the view (if applicable) and include it as a query parameter in the update calls.\n   * - The method returns immediately but the returned Promise needs to have a `then` or `catch` method call to handle the result or error respectively.\n   * - Uses `Promise.all` to wait for all update requests to complete before resolving the final result.\n   */\n  async clearAllActiveAlarms(\n    selectedSeverities: SeverityType[],\n    sourceId: string | number\n  ): Promise<{ resolvedImmediately: boolean }> {\n    const severitiesToUpdate = selectedSeverities || Severity;\n\n    const promises = Object.values(severitiesToUpdate).map((severity: SeverityType) => {\n      const commonParams = { resolved: false, severity };\n\n      const parameters = sourceId\n        ? {\n            ...commonParams,\n            source: sourceId,\n            withSourceAssets: true,\n            withSourceDevices: true\n          }\n        : commonParams;\n\n      return this.alarmService.updateBulk({ status: AlarmStatus.CLEARED }, parameters);\n    });\n\n    const responses = await Promise.all(promises);\n    return {\n      resolvedImmediately: responses.every(res => res)\n    };\n  }\n\n  /**\n   * Returns the correct link based on the provided context data.\n   * @param contextData The context the navigation was triggered from.\n   * @param alarm The alarm to navigate to.\n   * @returns A link to be used as an url navigation.\n   */\n  getRouterLink(contextData?: ContextData, alarm?: IAlarm): string {\n    let detailUrl = `/${ALARMS_PATH}`;\n    if (alarm) {\n      detailUrl = `/${ALARMS_PATH}/${alarm.id}`;\n    }\n    if (!contextData) {\n      return detailUrl;\n    }\n\n    switch (contextData.context) {\n      case ViewContext.Device:\n        return `/device/${contextData.contextData.id}${detailUrl}`;\n      case ViewContext.Group:\n        return `/group/${contextData.contextData.id}${detailUrl}`;\n      case ViewContext.Simulators:\n        return `/simulators/${contextData.contextData.id}${detailUrl}`;\n      default:\n        return detailUrl;\n    }\n  }\n\n  /**\n   * Returns the correct array navigation.\n   * @param contextData The context the navigation was triggered from.\n   * @param alarm The alarm to navigate to.\n   * @returns A link to be used as a router.navigation.\n   */\n  getRouterNavigationArray(contextData?: ContextData, alarm?: IAlarm): string[] {\n    return this.getRouterLink(contextData, alarm).split('/').filter(Boolean);\n  }\n\n  /**\n   * Returns the correct from and to dates based on the selected interval\n   * @param intervalId the selected interval. E.g. 'none', 'hours', 'custom' ...\n   * @returns The calculated date context based on the selected interval.\n   */\n  getDateTimeContextByInterval(intervalId: AlarmFilterInterval['id']): DateTimeContext {\n    const interval = INTERVALS_EXTENDED.find(({ id }) => id === intervalId);\n    if (interval.id === 'none') {\n      return [new Date(0), new Date()];\n    }\n\n    const dateTo = new Date();\n    const dateFrom = new Date(dateTo.valueOf() - interval.timespanInMs);\n    return [dateFrom, dateTo];\n  }\n\n  /**\n   * Creates a value for query parameter for filtering alarms by severity based on array of selected severities.\n   *\n   * @param severities - An array of alarm severity types to include in the filter.\n   * If the array is empty or undefined, no severity filter will be applied.\n   *\n   * @returns A comma-separated string of selected alarm severities,\n   * or null if no severities are provided.\n   */\n  private getSeverityQueryParameter(severities: SeverityType[]): string | null {\n    if (!severities || severities.length === 0) {\n      return;\n    }\n    if (severities.length === Object.keys(Severity).length) {\n      return;\n    }\n\n    return severities.join(',');\n  }\n\n  /**\n   * Creates a value for query parameter for filtering alarms by statuses based on showCleared option.\n   *\n   * @param showCleared - A flag indicating whether to include cleared statuses.\n   * If true, all statuses, including 'CLEARED', will be included; if false, 'CLEARED' will be excluded.\n   *\n   * @returns A comma-separated string of alarm statuses.\n   */\n  private getStatusQueryParameter(showCleared: boolean): string {\n    const statuses = Object.keys(ALARM_STATUS_LABELS) as AlarmStatusType[];\n    const filteredStatuses = showCleared\n      ? statuses\n      : statuses.filter(status => status !== 'CLEARED');\n    return filteredStatuses.join(',');\n  }\n}\n"]}