@quadrel-enterprise-ui/framework 18.19.1 → 18.19.2

package/esm2022/lib/notifications/notification/notification.component.mjs

@@ -99,6 +99,42 @@ import * as i5 from "@ngx-translate/core";
  * }
  * ```
  *
+ * ### Whitelisting HTTP status codes
+ *
+ * In some cases, you might want to prevent certain HTTP status codes from triggering error notifications. For example, a 304 Not Modified response is not actually an error and should not display an error notification. The **QdUiModule** allows you to whitelist specific HTTP status codes.
+ *
+ * To whitelist HTTP status codes, pass an array of status codes as the third parameter to the **QdUiModule.forRoot** method:
+ *
+ * ```typescript
+ * import { HttpStatusCode } from '@angular/common/http';
+ *
+ * imports: [
+ *   ...
+ *   QdUiModule.forRoot(
+ *     appEnvironment,
+ *     ErrorCodes,
+ *     [HttpStatusCode.NotModified, HttpStatusCode.NoContent] // Whitelist 304 Not Modified and 204 No Content
+ *   ),
+ *   ...
+ * ]
+ * ```
+ *
+ * When a response with a whitelisted status code is received, no error notification will be displayed, even if it would normally be treated as an error by the HTTP client.
+ *
+ * ### Blacklisting HTTP status codes
+ *
+ * For critical errors, notifications are always shown, even if the status code is whitelisted. The **QdUiModule** implements a fixed blacklist that takes precedence over the whitelist.
+ *
+ * The following status codes are permanently blacklisted:
+ * - 401 Unauthorized
+ * - 402 Payment Required
+ * - 403 Forbidden
+ * - All 5xx server error codes (500-511)
+ *
+ * These critical errors will always show notifications, even if they are included in the whitelist.
+ *
+ * **Important**: The blacklist has higher precedence than the whitelist. If a status code appears in both the whitelist and the blacklist, it will be treated as blacklisted, and an error notification will be shown.
+ *
  * ### Component:
  *
  * ```typescript
@@ -508,4 +544,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImpor
                 type: HostBinding,
                 args: ['attr.class']
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"notification.component.js","sourceRoot":"","sources":["../../../../../../libs/qd-ui/src/lib/notifications/notification/notification.component.ts","../../../../../../libs/qd-ui/src/lib/notifications/notification/notification.component.html"],"names":[],"mappings":"AAAA,oBAAoB;AACpB,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,WAAW,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAE1E,OAAO,EAAE,sBAAsB,EAAE,MAAM,2CAA2C,CAAC;AACnF,OAAO,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;;;;;;;AAEjE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAibG;AAOH,MAAM,OAAO,uBAAuB;IAoBf;IACA;IACT;IArBV;;OAEG;IACM,IAAI,GAAuB,UAAU,CAAC;IAE/C;;OAEG;IACM,YAAY,CAAiB;IAEtC,IAA+B,aAAa;QAC1C,OAAO,mCAAmC,IAAI,CAAC,OAAO,EAAE,EAAE,CAAC;IAC7D,CAAC;IAED,IAAI,SAAS;QACX,OAAO,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,YAAY,CAAC,CAAC,CAAC,IAAI,CAAC;IACpE,CAAC;IAED,YACmB,mBAA2C,EAC3C,eAAkC,EAC3C,OAAmB;QAFV,wBAAmB,GAAnB,mBAAmB,CAAwB;QAC3C,oBAAe,GAAf,eAAe,CAAmB;QAC3C,YAAO,GAAP,OAAO,CAAY;IAC1B,CAAC;IAEJ,OAAO;QACL,OAAO,IAAI,CAAC,YAAY,EAAE,IAAI,IAAI,IAAI,CAAC,IAAI,CAAC;IAC9C,CAAC;IAED,OAAO;QACL,QAAQ,IAAI,CAAC,OAAO,EAAE,EAAE,CAAC;YACvB,KAAK,SAAS;gBACZ,OAAO,kBAAkB,CAAC;YAC5B,KAAK,MAAM;gBACT,OAAO,kBAAkB,CAAC;YAC5B,KAAK,SAAS;gBACZ,OAAO,kBAAkB,CAAC;YAC5B,KAAK,UAAU;gBACb,OAAO,wBAAwB,CAAC;QACpC,CAAC;IACH,CAAC;IAED,MAAM;QACJ,IAAI,IAAI,CAAC,wBAAwB,EAAE,EAAE,CAAC;YACpC,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;QACrD,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,mBAAmB,CAAC,MAAM,CAAC,IAAI,CAAC,YAAY,CAAC,OAAO,EAAE,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;QACrF,CAAC;IACH,CAAC;IAED,eAAe;QACb,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC;IACnC,CAAC;IAEO,wBAAwB;QAC9B,OAAO,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC;IAC7D,CAAC;uGAxDU,uBAAuB;2FAAvB,uBAAuB,gNC9bpC,giBAUA;;2FDoba,uBAAuB;kBANnC,SAAS;+BACE,iBAAiB,QAGrB,EAAE,KAAK,EAAE,iBAAiB,EAAE;oJAMzB,IAAI;sBAAZ,KAAK;gBAKG,YAAY;sBAApB,KAAK;gBAEyB,aAAa;sBAA3C,WAAW;uBAAC,YAAY","sourcesContent":["// @ts-strict-ignore\nimport { Component, ElementRef, HostBinding, Input } from '@angular/core';\nimport { QdNotification, QdNotificationType } from '../interfaces/notifications';\nimport { QdNotificationsService } from '../services/notifications-service.service';\nimport { QdSnackbarService } from '../services/snackbar.service';\n\n/**\n *  **QdNotification** displays a single notification item within a **QdNotifications** container.\n *\n * # Notifications Service\n *\n * The **Notifications Service** can be used to catch errors from the backend. In addition, this service provides several methods to display messages.\n *\n * ## Notification from Backend\n *\n * The **QdUiModule** provides an HTTP interceptor that displays request errors as snackbar notifications. To get the proper notification messages for the corresponding backend errors, please comply with these conventions.\n *\n * ### Example of a response object\n *\n * The backend service response has to contain an errorCode field. This error code will be mapped to get the translation for the notification message.\n *\n * ```json\n * {\n *   \"errorCode\": \"TRANSPORT_COCKPIT_PERSISTENCE_ERROR\",\n *   \"errorMessage\": \"TRANSPORT_COCKPIT_PERSISTENCE_ERROR: Could not find Declaration wih id: b78e0734-ae1b-434e-b44d-b48797f5696d\"\n * }\n * ```\n *\n * ### Define Error Codes in the QdUiModule\n *\n * The **QdUiModule** expects an enum with error codes as the second parameter. For these given error codes you can define specific notification messages.\n *\n * This is an example configuration of the **QdUiModule** in the **app.module.ts**.\n *\n * ```typescript\n * enum ErrorCodes {\n *   TRANSPORT_COCKPIT_PERSISTENCE_ERROR,\n *   TRANSPORT_COCKPIT_VALIDATION_ERROR\n * }\n * ```\n *\n * ```typescript\n * imports: [\n *   ...\n *   QdUiModule.forRoot(appEnvironment, ErrorCodes),\n *   ...\n * ]\n * ```\n *\n * ### Translations:\n *\n * You can define the specific backend error notification messages for the respective error codes under `\"ERROR\"` in the translation files.\n *\n * ```json\n * {\n *   ...\n *\n *   \"ERROR\": {\n *     \"TRANSPORT_COCKPIT_PERSISTENCE_ERROR\": \"In der Datenbank ist ein Fehler aufgetreten\",\n *     \"TRANSPORT_COCKPIT_VALIDATION_ERROR\": \"Ungültige Eingabe\"\n *   }\n * }\n * ```\n *\n * ### Default error messages\n *\n * A default error message is shown if no error code is given in the backend response or the error code is not defined in the `ErrorCodes` enum that you pass to the **QdUiModule**.\n *\n * To override the default error messages you have to add the corresponding HTTP error code in the `ErrorCodes` enum. Then you can define a custom default error message in the translation files.\n *\n * ```typescript\n * enum ErrorCodes {\n *   ...,\n *   HTTP_BAD_REQUEST,\n *   HTTP_UNAUTHORIZED,\n *   HTTP_FORBIDDEN,\n *   HTTP_NOT_FOUND,\n *   HTTP_SERVER_ERROR,\n *   HTTP_UNKNOWN_ERROR\n * }\n * ```\n *\n * ```json\n * {\n *   ...\n *\n *   \"ERROR\": {\n *     \"HTTP_BAD_REQUEST\": \"This is a custom error message for a response with the HTTP status code 400.\",\n *     \"HTTP_UNAUTHORIZED\": \"This is a custom error message for a response with the HTTP status code 401.\",\n *     \"HTTP_FORBIDDEN\": \"This is a custom error message for a response with the HTTP status code 403.\",\n *     \"HTTP_NOT_FOUND\": \"This is a custom error message for a response with the HTTP status code 404.\",\n *     \"HTTP_SERVER_ERROR\": \"This is a custom error message for a response with some server error (HTTP status code 5xx).\",\n *     \"HTTP_UNKNOWN_ERROR\": \"This is a custom error message for all other errors.\"\n *   }\n * }\n * ```\n *\n * ### Component:\n *\n * ```typescript\n * class MyNotificationComponent {\n *   data;\n *\n *   constructor(private http: HttpClient) {}\n *\n *   private setData(data) {\n *     this.data = data;\n *   }\n *\n *   public callApiEndPoint() {\n *     // This way you can display the content in the frontend.\n *     return this.http.get('route/to/endpoint').subscribe({\n *       next: res => this.setData(res),\n *       error: err => this.setData(err)\n *     });\n *   }\n * }\n * ```\n *\n * The errors are rendered into a container, which by default has the attribute `context=\"qdPanel\"`.\n *\n * ```html\n * <!-- Landing pad for notifications -->\n * <qd-notifications></qd-notifications>\n * ```\n *\n * ## Notifications via service\n *\n * ### Interfaces:\n *\n * ```typescript\n * interface QdNotification {\n *   uuid?: string;\n *   context?: string;\n *   type: QdNotificationType;\n *   i18n: QdNotificationTranslation;\n *   title?: QdNotificationTitle;\n *   date?: Date;\n *   lifeTime?: number;\n *   disableClose?: boolean;\n *   onClose?: () => void;\n *   showAsSnackbar?: boolean;\n *   snackbarOptions?: QdSnackbarNotificationOptions;\n *   showAsOsNotification?: boolean;\n *   osNotificationOptions?: QdOsNotificationOptions;\n * }\n *\n * type QdNotificationType = 'info' | 'warning' | 'critical' | 'success';\n *\n * type QdNotificationTranslation = string;\n * type QdNotificationTitle = { i18n: string };\n *\n * type QdNotifications = QdNotification[];\n *\n * interface QdSnackbarNotificationOptions {\n *   lifeTime?: number;\n *   disableClose?: boolean;\n *   onClose?: () => void;\n * }\n *\n * interface QdOsNotificationOptions {\n *   silent?: boolean;\n *   lifeTime?: number;\n *   onClose?: (event) => void;\n *   onClick?: (event) => void;\n * }\n * ```\n *\n * The Notifications Service provides some methods to display them in the frontend.\n *\n * ### Component\n *\n * ```typescript\n * class MyNotificationComponent {\n *   constructor(private notificationsService: QdNotificationsService) {}\n *\n *   public add(context: string, notification: QdNotification): void {\n *     this.notificationsService.add(context, notification);\n *   }\n * }\n * ```\n *\n * ### Type QdNotification (Second param of the add method)\n *\n * ```typescript\n * interface QdNotification {\n *   ...\n *\n *   type: QdNotificationType;\n *   i18n: string;\n *   lifeTime?: number;\n * }\n *\n * type QdNotifications = QdNotification[];\n * ```\n *\n * ### Type QdNotificationType\n *\n * ```typescript\n * type QdNotificationType = 'info' | 'warning' | 'critical' | 'success';\n * ```\n *\n * ### Template\n *\n * ```html\n * <button (click)=\"add('qdPanel', { type: 'critical', i18n: 'i18n.error.critical' })\">Add Notification</button>\n * ```\n *\n * ### Template for displaying notifications - for instance in the Info Panel\n *\n * ```html\n * <qd-notifications></qd-notifications>\n * ```\n *\n * ## Notifications as a snackbar\n *\n * You can also display the notifications as a snack bar. They are then on top of the layout system. What you need to do is to place the directive `qdSnackbarListener` there. Also, just add the `showAsSnackbar` parameter to the method call.\n *\n * ### Example\n *\n * ```html\n * <qd-container qdSnackbarListener> My Container Content </qd-container>\n *\n * <button (click)=\"addNotification('qdPanel', { type: 'critical', i18n: 'i18n.error.critical', showAsSnackbar: true })\">\n *   Add Notification\n * </button>\n * ```\n *\n * All notifications are now displayed by the directive contained in the `qd-container`. Also, all notifications from the backend are displayed there.\n *\n * **Recommendation of the Quadrel Team**: Place the `qdSnackbarListener` directly on top of the layout system - so for example in the **AppComponent**.\n *\n * ### Options\n *\n * You can also pass a configuration object in the `snackbarOptions` parameter to customize the snackbar notification or to set an `onClose` handler.\n * When you close the main notification, the snackbar notification will be closed automatically. The snackbar notification can be closed for itself alone.\n *\n * In the `snackbarOptions` configuration object you can override the properties `disableClose` and `lifeTime`. When the main notification is closed,\n * the snackbar notification will also be closed. So the life time of the snackbar notification only can be shorter.\n *\n * ## OS Notifications\n *\n * To bring a notification to the foreground, even if the application window is not in focus, you can also push the notification as an OS Notification.\n * Then the notification will also be pushed through the Notification browser API and will be displayed on your operating system (e.g. Windows/Linux).\n * In the future, the OS Notifications will also be pushed as smartphone system notifications. Currently, only desktop notifications are supported.\n *\n * ### Example\n *\n * ```html\n * <button (click)=\"addNotification('qdPanel', { type: 'critical', i18n: 'i18n.error.critical', showAsOsNotification: true })\">\n *   Add Notification\n * </button>\n * ```\n *\n * ### Options\n *\n * You can also pass a configuration object in the `osNotificationOptions` parameter to customize the OS notification or to set `onClick` and `onClose` handlers.\n * When you close the main notification, the OS notification will be closed automatically. The OS notification can be closed for itself alone.\n *\n * In the `osNotificationOptions` configuration object you can override the properties `disableClose` and `lifeTime`. When the main notification is closed,\n * the OS notification will also be closed. So the life time of the OS notification only can be shorter.\n *\n * ### Deep links\n *\n * To open a deep link when the OS notification is clicked, use the following code for the click handler:\n *\n * ```typescript\n * event.preventDefault();\n * window.open('https://your/deep/link');\n * ```\n *\n * ## Notifications via service (multiple instances)\n *\n * ### Object of multiple notifications\n *\n * ```typescript\n * const BULK: QdNotifications = [\n *   {\n *     type: 'critical',\n *     i18n: 'i18n.error.1'\n *   },\n *   {\n *     type: 'critical',\n *     i18n: 'i18n.error.2'\n *   }\n * ];\n * ```\n *\n * ### Component\n *\n * ```typescript\n * class MyNotificationComponent {\n *   bulk: QdNotifications = BULK;\n *\n *   constructor(private notificationsService: QdNotificationsService, public modalService: QdModalService) {}\n *\n *   openNotificationModal(mrn) {\n *     // MRN represents a unique context\n *     this.modalService.open(MyNotificationModalComponent, { data: { mrn } });\n *\n *     // Adds the notifications when opening\n *     this.notificationsService.addBulk(mrn, this.bulk);\n *   }\n * }\n * ```\n *\n * ### Template\n *\n * ```html\n * <mat-table [dataSource]=\"dataSource\">\n *   <ng-container matColumnDef=\"mrn\">\n *     <mat-header-cell *matHeaderCellDef class=\"center\">Mrn.</mat-header-cell>\n *     <mat-cell *matCellDef=\"let element\" class=\"center\">\n *       <button mat-button color=\"primary\" (click)=\"openNotificationModal(element.mrn)\">\n *         <!-- MRN represents a unique context -->\n *         {{ element.mrn }}\n *       </button>\n *     </mat-cell>\n *   </ng-container>\n * </mat-table>\n * ```\n *\n * ## Notification Events\n *\n * You can define an `onClose` callback for each notification type. When the main notification is closed, then\n * the corresponding snackbar notification and OS notification will also be closed and all events will be fired.\n *\n * ```typescript\n * class MyNotificationComponent {\n *   constructor(private notificationsService: QdNotificationsService) {}\n *\n *   showNotification(): void {\n *     this.notificationsService.add(\n *       'qdPanel',\n *       {\n *         type: 'critical',\n *         i18n: 'i18n.error.critical',\n *         onClose: () => console.log('Notification closed.'),\n *         showAsSnackbar: true,\n *         snackbarOptions: {\n *           onClose: () => console.log('Snackbar Notification closed.')\n *         }\n *         showAsOsNotification: true,\n *         osNotificationOptions: {\n *           onClose: () => console.log('OS Notification closed.')\n *         }\n *       }\n *     );\n *   }\n * }\n * ```\n *\n * Especially for the OS notification an `onClick` handler can be defined. With the onClick handler it's also possible\n * to define a deep link that will be opened on click with the following code:\n *\n * ```typescript\n * this.notificationsService.add(\n *   'qdPanel',\n *   {\n *     type: 'critical',\n *     i18n: 'i18n.error.critical',\n *     showAsOsNotification: true,\n *     osNotificationOptions: {\n *       onClick: (event) => {\n *         event.preventDefault();\n *         window.open('https://your/deep/link');\n *       }\n *     }\n *   }\n * );\n * ```\n *\n * ## Inline Notifications\n *\n * Notifications can also be inserted directly into the template.\n *\n * ```html\n * <qd-notification [type]=\"type\" [notification]=\"notification\">\n *   <qd-notification-content> test notification content </qd-notification-content>\n * </qd-notification>\n * ```\n *\n * ```typescript\n * // The type can be defined with the type input\n * type = 'critical';\n *\n * // ... or in the notification config\n * notification: QdNotification = {\n *   type: 'critical'\n * }\n * ```\n *\n * The content can also be defined in the config. Then you don't have to put a `qd-notification-content`\n * element into the `qd-notification`.\n *\n * ```html\n * <qd-notification [notification]=\"notification\"></qd-notification>\n * ```\n *\n * ```typescript\n * notification: QdNotification = {\n *   type: 'critical',\n *   i18n: 'i18n.error.critical'\n * }\n * ```\n *\n * ## Multiline Notifications\n *\n * To create a multiline notification you simply can insert `\\n` in the i18n translation text. Line breaks (`\\n`) are\n * not considered if you use the `<qd-notification-content>` variant. Line breaks only work if you define the\n * i18n key in the notification config.\n *\n * ### Example\n *\n * ```typescript\n * notification: QdNotification = {\n *   type: 'warning',\n *   i18n: 'i18n.ncts.declaration.detailInventoryResult.notification.transitDeadlineExpired'\n * }\n * ```\n *\n * ```json\n * {\n *   ...\n *\n *   \"i18n.ncts.declaration.detailInventoryResult.notification.transitDeadlineExpired\": \"The inventory result must be checked and the control result recorded. \\nAttention: The transit period has expired upon arrival at the Authorized Place\",\n * }\n * ```\n *\n * ### Notifications Service\n *\n * | Method                       | Params                                                 | description                                      | default |\n * | ---------------------------- | ------------------------------------------------------ | ------------------------------------------------ | ------- |\n * | getNotificationsForContext() | context: string                                        | Returns notification stream for context.         | -       |\n * | add()                        | context: string, notification: QdNotification          | Adds a single notification.                      | -       |\n * | addBulk()                    | context: string, notifications: QdNotifications        | Adds multiple notifications.                     | -       |\n * | remove()                     | context: string, id: string                            | Removes specific notification.                   | -       |\n * | removeAll()                  | context: string                                        | Removes all notifications in context.            | -       |\n * | reset()                      | -                                                      | Clear all notifications.                         | -       |\n */\n@Component({\n  selector: 'qd-notification',\n  templateUrl: './notification.component.html',\n  styleUrls: ['./notification.component.scss'],\n  host: { class: 'qd-notification' }\n})\nexport class QdNotificationComponent {\n  /**\n   * Defines the type of this notification.\n   */\n  @Input() type: QdNotificationType = 'critical';\n\n  /**\n   * Configuration of a notification.\n   */\n  @Input() notification: QdNotification;\n\n  @HostBinding('attr.class') get typeClassName(): string {\n    return `qd-notification qd-notification-${this.getType()}`;\n  }\n\n  get closeable(): boolean {\n    return this.notification ? !this.notification.disableClose : true;\n  }\n\n  constructor(\n    private readonly notificationService: QdNotificationsService,\n    private readonly snackbarService: QdSnackbarService,\n    private element: ElementRef\n  ) {}\n\n  getType(): QdNotificationType {\n    return this.notification?.type || this.type;\n  }\n\n  getIcon(): string {\n    switch (this.getType()) {\n      case 'success':\n        return 'checkCircleSolid';\n      case 'info':\n        return 'checkCircleSolid';\n      case 'warning':\n        return 'warningHexFilled';\n      case 'critical':\n        return 'exclamationCircleSolid';\n    }\n  }\n\n  remove(): void {\n    if (this.isNotificationInSnackbar()) {\n      this.snackbarService.close(this.notification.uuid);\n    } else {\n      this.notificationService.remove(this.notification.context, this.notification.uuid);\n    }\n  }\n\n  handleLinkClick(): void {\n    this.notification.link.handler();\n  }\n\n  private isNotificationInSnackbar(): boolean {\n    return !!this.element.nativeElement.closest('qd-snackbar');\n  }\n}\n","<qd-icon *ngIf=\"closeable\" [icon]=\"'timesLarge'\" class=\"closer\" (click)=\"remove()\"></qd-icon>\n<qd-icon [icon]=\"this.getIcon()\" class=\"icon\"></qd-icon>\n\n<ng-content select=\"qd-notification-content\"></ng-content>\n\n<div class=\"title\" *ngIf=\"notification?.title\">{{ notification.title.i18n | translate }}</div>\n<div class=\"message\">\n  <span>{{ notification?.i18n | translate }}</span>\n  <a class=\"link\" *ngIf=\"notification?.link\" (click)=\"handleLinkClick()\">{{ notification.link.i18n | translate }}</a>\n</div>\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"notification.component.js","sourceRoot":"","sources":["../../../../../../libs/qd-ui/src/lib/notifications/notification/notification.component.ts","../../../../../../libs/qd-ui/src/lib/notifications/notification/notification.component.html"],"names":[],"mappings":"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","sourcesContent":["// @ts-strict-ignore\nimport { Component, ElementRef, HostBinding, Input } from '@angular/core';\nimport { QdNotification, QdNotificationType } from '../interfaces/notifications';\nimport { QdNotificationsService } from '../services/notifications-service.service';\nimport { QdSnackbarService } from '../services/snackbar.service';\n\n/**\n *  **QdNotification** displays a single notification item within a **QdNotifications** container.\n *\n * # Notifications Service\n *\n * The **Notifications Service** can be used to catch errors from the backend. In addition, this service provides several methods to display messages.\n *\n * ## Notification from Backend\n *\n * The **QdUiModule** provides an HTTP interceptor that displays request errors as snackbar notifications. To get the proper notification messages for the corresponding backend errors, please comply with these conventions.\n *\n * ### Example of a response object\n *\n * The backend service response has to contain an errorCode field. This error code will be mapped to get the translation for the notification message.\n *\n * ```json\n * {\n *   \"errorCode\": \"TRANSPORT_COCKPIT_PERSISTENCE_ERROR\",\n *   \"errorMessage\": \"TRANSPORT_COCKPIT_PERSISTENCE_ERROR: Could not find Declaration wih id: b78e0734-ae1b-434e-b44d-b48797f5696d\"\n * }\n * ```\n *\n * ### Define Error Codes in the QdUiModule\n *\n * The **QdUiModule** expects an enum with error codes as the second parameter. For these given error codes you can define specific notification messages.\n *\n * This is an example configuration of the **QdUiModule** in the **app.module.ts**.\n *\n * ```typescript\n * enum ErrorCodes {\n *   TRANSPORT_COCKPIT_PERSISTENCE_ERROR,\n *   TRANSPORT_COCKPIT_VALIDATION_ERROR\n * }\n * ```\n *\n * ```typescript\n * imports: [\n *   ...\n *   QdUiModule.forRoot(appEnvironment, ErrorCodes),\n *   ...\n * ]\n * ```\n *\n * ### Translations:\n *\n * You can define the specific backend error notification messages for the respective error codes under `\"ERROR\"` in the translation files.\n *\n * ```json\n * {\n *   ...\n *\n *   \"ERROR\": {\n *     \"TRANSPORT_COCKPIT_PERSISTENCE_ERROR\": \"In der Datenbank ist ein Fehler aufgetreten\",\n *     \"TRANSPORT_COCKPIT_VALIDATION_ERROR\": \"Ungültige Eingabe\"\n *   }\n * }\n * ```\n *\n * ### Default error messages\n *\n * A default error message is shown if no error code is given in the backend response or the error code is not defined in the `ErrorCodes` enum that you pass to the **QdUiModule**.\n *\n * To override the default error messages you have to add the corresponding HTTP error code in the `ErrorCodes` enum. Then you can define a custom default error message in the translation files.\n *\n * ```typescript\n * enum ErrorCodes {\n *   ...,\n *   HTTP_BAD_REQUEST,\n *   HTTP_UNAUTHORIZED,\n *   HTTP_FORBIDDEN,\n *   HTTP_NOT_FOUND,\n *   HTTP_SERVER_ERROR,\n *   HTTP_UNKNOWN_ERROR\n * }\n * ```\n *\n * ```json\n * {\n *   ...\n *\n *   \"ERROR\": {\n *     \"HTTP_BAD_REQUEST\": \"This is a custom error message for a response with the HTTP status code 400.\",\n *     \"HTTP_UNAUTHORIZED\": \"This is a custom error message for a response with the HTTP status code 401.\",\n *     \"HTTP_FORBIDDEN\": \"This is a custom error message for a response with the HTTP status code 403.\",\n *     \"HTTP_NOT_FOUND\": \"This is a custom error message for a response with the HTTP status code 404.\",\n *     \"HTTP_SERVER_ERROR\": \"This is a custom error message for a response with some server error (HTTP status code 5xx).\",\n *     \"HTTP_UNKNOWN_ERROR\": \"This is a custom error message for all other errors.\"\n *   }\n * }\n * ```\n *\n * ### Whitelisting HTTP status codes\n *\n * In some cases, you might want to prevent certain HTTP status codes from triggering error notifications. For example, a 304 Not Modified response is not actually an error and should not display an error notification. The **QdUiModule** allows you to whitelist specific HTTP status codes.\n *\n * To whitelist HTTP status codes, pass an array of status codes as the third parameter to the **QdUiModule.forRoot** method:\n *\n * ```typescript\n * import { HttpStatusCode } from '@angular/common/http';\n *\n * imports: [\n *   ...\n *   QdUiModule.forRoot(\n *     appEnvironment,\n *     ErrorCodes,\n *     [HttpStatusCode.NotModified, HttpStatusCode.NoContent] // Whitelist 304 Not Modified and 204 No Content\n *   ),\n *   ...\n * ]\n * ```\n *\n * When a response with a whitelisted status code is received, no error notification will be displayed, even if it would normally be treated as an error by the HTTP client.\n *\n * ### Blacklisting HTTP status codes\n *\n * For critical errors, notifications are always shown, even if the status code is whitelisted. The **QdUiModule** implements a fixed blacklist that takes precedence over the whitelist.\n *\n * The following status codes are permanently blacklisted:\n * - 401 Unauthorized\n * - 402 Payment Required\n * - 403 Forbidden\n * - All 5xx server error codes (500-511)\n *\n * These critical errors will always show notifications, even if they are included in the whitelist.\n *\n * **Important**: The blacklist has higher precedence than the whitelist. If a status code appears in both the whitelist and the blacklist, it will be treated as blacklisted, and an error notification will be shown.\n *\n * ### Component:\n *\n * ```typescript\n * class MyNotificationComponent {\n *   data;\n *\n *   constructor(private http: HttpClient) {}\n *\n *   private setData(data) {\n *     this.data = data;\n *   }\n *\n *   public callApiEndPoint() {\n *     // This way you can display the content in the frontend.\n *     return this.http.get('route/to/endpoint').subscribe({\n *       next: res => this.setData(res),\n *       error: err => this.setData(err)\n *     });\n *   }\n * }\n * ```\n *\n * The errors are rendered into a container, which by default has the attribute `context=\"qdPanel\"`.\n *\n * ```html\n * <!-- Landing pad for notifications -->\n * <qd-notifications></qd-notifications>\n * ```\n *\n * ## Notifications via service\n *\n * ### Interfaces:\n *\n * ```typescript\n * interface QdNotification {\n *   uuid?: string;\n *   context?: string;\n *   type: QdNotificationType;\n *   i18n: QdNotificationTranslation;\n *   title?: QdNotificationTitle;\n *   date?: Date;\n *   lifeTime?: number;\n *   disableClose?: boolean;\n *   onClose?: () => void;\n *   showAsSnackbar?: boolean;\n *   snackbarOptions?: QdSnackbarNotificationOptions;\n *   showAsOsNotification?: boolean;\n *   osNotificationOptions?: QdOsNotificationOptions;\n * }\n *\n * type QdNotificationType = 'info' | 'warning' | 'critical' | 'success';\n *\n * type QdNotificationTranslation = string;\n * type QdNotificationTitle = { i18n: string };\n *\n * type QdNotifications = QdNotification[];\n *\n * interface QdSnackbarNotificationOptions {\n *   lifeTime?: number;\n *   disableClose?: boolean;\n *   onClose?: () => void;\n * }\n *\n * interface QdOsNotificationOptions {\n *   silent?: boolean;\n *   lifeTime?: number;\n *   onClose?: (event) => void;\n *   onClick?: (event) => void;\n * }\n * ```\n *\n * The Notifications Service provides some methods to display them in the frontend.\n *\n * ### Component\n *\n * ```typescript\n * class MyNotificationComponent {\n *   constructor(private notificationsService: QdNotificationsService) {}\n *\n *   public add(context: string, notification: QdNotification): void {\n *     this.notificationsService.add(context, notification);\n *   }\n * }\n * ```\n *\n * ### Type QdNotification (Second param of the add method)\n *\n * ```typescript\n * interface QdNotification {\n *   ...\n *\n *   type: QdNotificationType;\n *   i18n: string;\n *   lifeTime?: number;\n * }\n *\n * type QdNotifications = QdNotification[];\n * ```\n *\n * ### Type QdNotificationType\n *\n * ```typescript\n * type QdNotificationType = 'info' | 'warning' | 'critical' | 'success';\n * ```\n *\n * ### Template\n *\n * ```html\n * <button (click)=\"add('qdPanel', { type: 'critical', i18n: 'i18n.error.critical' })\">Add Notification</button>\n * ```\n *\n * ### Template for displaying notifications - for instance in the Info Panel\n *\n * ```html\n * <qd-notifications></qd-notifications>\n * ```\n *\n * ## Notifications as a snackbar\n *\n * You can also display the notifications as a snack bar. They are then on top of the layout system. What you need to do is to place the directive `qdSnackbarListener` there. Also, just add the `showAsSnackbar` parameter to the method call.\n *\n * ### Example\n *\n * ```html\n * <qd-container qdSnackbarListener> My Container Content </qd-container>\n *\n * <button (click)=\"addNotification('qdPanel', { type: 'critical', i18n: 'i18n.error.critical', showAsSnackbar: true })\">\n *   Add Notification\n * </button>\n * ```\n *\n * All notifications are now displayed by the directive contained in the `qd-container`. Also, all notifications from the backend are displayed there.\n *\n * **Recommendation of the Quadrel Team**: Place the `qdSnackbarListener` directly on top of the layout system - so for example in the **AppComponent**.\n *\n * ### Options\n *\n * You can also pass a configuration object in the `snackbarOptions` parameter to customize the snackbar notification or to set an `onClose` handler.\n * When you close the main notification, the snackbar notification will be closed automatically. The snackbar notification can be closed for itself alone.\n *\n * In the `snackbarOptions` configuration object you can override the properties `disableClose` and `lifeTime`. When the main notification is closed,\n * the snackbar notification will also be closed. So the life time of the snackbar notification only can be shorter.\n *\n * ## OS Notifications\n *\n * To bring a notification to the foreground, even if the application window is not in focus, you can also push the notification as an OS Notification.\n * Then the notification will also be pushed through the Notification browser API and will be displayed on your operating system (e.g. Windows/Linux).\n * In the future, the OS Notifications will also be pushed as smartphone system notifications. Currently, only desktop notifications are supported.\n *\n * ### Example\n *\n * ```html\n * <button (click)=\"addNotification('qdPanel', { type: 'critical', i18n: 'i18n.error.critical', showAsOsNotification: true })\">\n *   Add Notification\n * </button>\n * ```\n *\n * ### Options\n *\n * You can also pass a configuration object in the `osNotificationOptions` parameter to customize the OS notification or to set `onClick` and `onClose` handlers.\n * When you close the main notification, the OS notification will be closed automatically. The OS notification can be closed for itself alone.\n *\n * In the `osNotificationOptions` configuration object you can override the properties `disableClose` and `lifeTime`. When the main notification is closed,\n * the OS notification will also be closed. So the life time of the OS notification only can be shorter.\n *\n * ### Deep links\n *\n * To open a deep link when the OS notification is clicked, use the following code for the click handler:\n *\n * ```typescript\n * event.preventDefault();\n * window.open('https://your/deep/link');\n * ```\n *\n * ## Notifications via service (multiple instances)\n *\n * ### Object of multiple notifications\n *\n * ```typescript\n * const BULK: QdNotifications = [\n *   {\n *     type: 'critical',\n *     i18n: 'i18n.error.1'\n *   },\n *   {\n *     type: 'critical',\n *     i18n: 'i18n.error.2'\n *   }\n * ];\n * ```\n *\n * ### Component\n *\n * ```typescript\n * class MyNotificationComponent {\n *   bulk: QdNotifications = BULK;\n *\n *   constructor(private notificationsService: QdNotificationsService, public modalService: QdModalService) {}\n *\n *   openNotificationModal(mrn) {\n *     // MRN represents a unique context\n *     this.modalService.open(MyNotificationModalComponent, { data: { mrn } });\n *\n *     // Adds the notifications when opening\n *     this.notificationsService.addBulk(mrn, this.bulk);\n *   }\n * }\n * ```\n *\n * ### Template\n *\n * ```html\n * <mat-table [dataSource]=\"dataSource\">\n *   <ng-container matColumnDef=\"mrn\">\n *     <mat-header-cell *matHeaderCellDef class=\"center\">Mrn.</mat-header-cell>\n *     <mat-cell *matCellDef=\"let element\" class=\"center\">\n *       <button mat-button color=\"primary\" (click)=\"openNotificationModal(element.mrn)\">\n *         <!-- MRN represents a unique context -->\n *         {{ element.mrn }}\n *       </button>\n *     </mat-cell>\n *   </ng-container>\n * </mat-table>\n * ```\n *\n * ## Notification Events\n *\n * You can define an `onClose` callback for each notification type. When the main notification is closed, then\n * the corresponding snackbar notification and OS notification will also be closed and all events will be fired.\n *\n * ```typescript\n * class MyNotificationComponent {\n *   constructor(private notificationsService: QdNotificationsService) {}\n *\n *   showNotification(): void {\n *     this.notificationsService.add(\n *       'qdPanel',\n *       {\n *         type: 'critical',\n *         i18n: 'i18n.error.critical',\n *         onClose: () => console.log('Notification closed.'),\n *         showAsSnackbar: true,\n *         snackbarOptions: {\n *           onClose: () => console.log('Snackbar Notification closed.')\n *         }\n *         showAsOsNotification: true,\n *         osNotificationOptions: {\n *           onClose: () => console.log('OS Notification closed.')\n *         }\n *       }\n *     );\n *   }\n * }\n * ```\n *\n * Especially for the OS notification an `onClick` handler can be defined. With the onClick handler it's also possible\n * to define a deep link that will be opened on click with the following code:\n *\n * ```typescript\n * this.notificationsService.add(\n *   'qdPanel',\n *   {\n *     type: 'critical',\n *     i18n: 'i18n.error.critical',\n *     showAsOsNotification: true,\n *     osNotificationOptions: {\n *       onClick: (event) => {\n *         event.preventDefault();\n *         window.open('https://your/deep/link');\n *       }\n *     }\n *   }\n * );\n * ```\n *\n * ## Inline Notifications\n *\n * Notifications can also be inserted directly into the template.\n *\n * ```html\n * <qd-notification [type]=\"type\" [notification]=\"notification\">\n *   <qd-notification-content> test notification content </qd-notification-content>\n * </qd-notification>\n * ```\n *\n * ```typescript\n * // The type can be defined with the type input\n * type = 'critical';\n *\n * // ... or in the notification config\n * notification: QdNotification = {\n *   type: 'critical'\n * }\n * ```\n *\n * The content can also be defined in the config. Then you don't have to put a `qd-notification-content`\n * element into the `qd-notification`.\n *\n * ```html\n * <qd-notification [notification]=\"notification\"></qd-notification>\n * ```\n *\n * ```typescript\n * notification: QdNotification = {\n *   type: 'critical',\n *   i18n: 'i18n.error.critical'\n * }\n * ```\n *\n * ## Multiline Notifications\n *\n * To create a multiline notification you simply can insert `\\n` in the i18n translation text. Line breaks (`\\n`) are\n * not considered if you use the `<qd-notification-content>` variant. Line breaks only work if you define the\n * i18n key in the notification config.\n *\n * ### Example\n *\n * ```typescript\n * notification: QdNotification = {\n *   type: 'warning',\n *   i18n: 'i18n.ncts.declaration.detailInventoryResult.notification.transitDeadlineExpired'\n * }\n * ```\n *\n * ```json\n * {\n *   ...\n *\n *   \"i18n.ncts.declaration.detailInventoryResult.notification.transitDeadlineExpired\": \"The inventory result must be checked and the control result recorded. \\nAttention: The transit period has expired upon arrival at the Authorized Place\",\n * }\n * ```\n *\n * ### Notifications Service\n *\n * | Method                       | Params                                                 | description                                      | default |\n * | ---------------------------- | ------------------------------------------------------ | ------------------------------------------------ | ------- |\n * | getNotificationsForContext() | context: string                                        | Returns notification stream for context.         | -       |\n * | add()                        | context: string, notification: QdNotification          | Adds a single notification.                      | -       |\n * | addBulk()                    | context: string, notifications: QdNotifications        | Adds multiple notifications.                     | -       |\n * | remove()                     | context: string, id: string                            | Removes specific notification.                   | -       |\n * | removeAll()                  | context: string                                        | Removes all notifications in context.            | -       |\n * | reset()                      | -                                                      | Clear all notifications.                         | -       |\n */\n@Component({\n  selector: 'qd-notification',\n  templateUrl: './notification.component.html',\n  styleUrls: ['./notification.component.scss'],\n  host: { class: 'qd-notification' }\n})\nexport class QdNotificationComponent {\n  /**\n   * Defines the type of this notification.\n   */\n  @Input() type: QdNotificationType = 'critical';\n\n  /**\n   * Configuration of a notification.\n   */\n  @Input() notification: QdNotification;\n\n  @HostBinding('attr.class') get typeClassName(): string {\n    return `qd-notification qd-notification-${this.getType()}`;\n  }\n\n  get closeable(): boolean {\n    return this.notification ? !this.notification.disableClose : true;\n  }\n\n  constructor(\n    private readonly notificationService: QdNotificationsService,\n    private readonly snackbarService: QdSnackbarService,\n    private element: ElementRef\n  ) {}\n\n  getType(): QdNotificationType {\n    return this.notification?.type || this.type;\n  }\n\n  getIcon(): string {\n    switch (this.getType()) {\n      case 'success':\n        return 'checkCircleSolid';\n      case 'info':\n        return 'checkCircleSolid';\n      case 'warning':\n        return 'warningHexFilled';\n      case 'critical':\n        return 'exclamationCircleSolid';\n    }\n  }\n\n  remove(): void {\n    if (this.isNotificationInSnackbar()) {\n      this.snackbarService.close(this.notification.uuid);\n    } else {\n      this.notificationService.remove(this.notification.context, this.notification.uuid);\n    }\n  }\n\n  handleLinkClick(): void {\n    this.notification.link.handler();\n  }\n\n  private isNotificationInSnackbar(): boolean {\n    return !!this.element.nativeElement.closest('qd-snackbar');\n  }\n}\n","<qd-icon *ngIf=\"closeable\" [icon]=\"'timesLarge'\" class=\"closer\" (click)=\"remove()\"></qd-icon>\n<qd-icon [icon]=\"this.getIcon()\" class=\"icon\"></qd-icon>\n\n<ng-content select=\"qd-notification-content\"></ng-content>\n\n<div class=\"title\" *ngIf=\"notification?.title\">{{ notification.title.i18n | translate }}</div>\n<div class=\"message\">\n  <span>{{ notification?.i18n | translate }}</span>\n  <a class=\"link\" *ngIf=\"notification?.link\" (click)=\"handleLinkClick()\">{{ notification.link.i18n | translate }}</a>\n</div>\n"]}

package/esm2022/lib/notifications/services/notifications-http-interceptor.service.mjs

@@ -10,27 +10,54 @@ import { QdNotificationsService } from './notifications-service.service';
 import * as i0 from "@angular/core";
 import * as i1 from "./notifications-service.service";
 export const BACKEND_ERROR_CODES = new InjectionToken('BACKEND_ERROR_CODES');
+export const WHITELIST_ERROR_CODES = new InjectionToken('WHITELIST_ERROR_CODES');
 /**
  * The QdNotificationsHttpInterceptorService is an Angular HTTP interceptor that captures error responses from HTTP requests and generates notifications for backend errors. This Service not only intercepts error responses, but it also handles specific error codes and translates them into appropriate error messages for display.
  */
 export class QdNotificationsHttpInterceptorService {
     appEnvironment;
     backendErrorCodes;
+    whitelistErrorCodes;
     notificationService;
-    constructor(appEnvironment, backendErrorCodes, notificationService) {
+    blacklistErrorCodes;
+    constructor(appEnvironment, backendErrorCodes, whitelistErrorCodes, notificationService) {
         this.appEnvironment = appEnvironment;
         this.backendErrorCodes = backendErrorCodes;
+        this.whitelistErrorCodes = whitelistErrorCodes;
         this.notificationService = notificationService;
         this.backendErrorCodes = this.backendErrorCodes || {};
+        this.whitelistErrorCodes = this.whitelistErrorCodes || [];
+        this.blacklistErrorCodes = [
+            // 401, 402, 403
+            HttpStatusCode.Unauthorized,
+            HttpStatusCode.PaymentRequired,
+            HttpStatusCode.Forbidden,
+            // All 5xx codes
+            HttpStatusCode.InternalServerError,
+            HttpStatusCode.NotImplemented,
+            HttpStatusCode.BadGateway,
+            HttpStatusCode.ServiceUnavailable,
+            HttpStatusCode.GatewayTimeout,
+            HttpStatusCode.HttpVersionNotSupported,
+            HttpStatusCode.VariantAlsoNegotiates,
+            HttpStatusCode.InsufficientStorage,
+            HttpStatusCode.LoopDetected,
+            HttpStatusCode.NotExtended,
+            HttpStatusCode.NetworkAuthenticationRequired
+        ];
     }
     intercept(request, next) {
         if (this.appEnvironment.disableBackendNotifications)
             return next.handle(request);
         return next.handle(request).pipe(catchError((error) => {
-            let i18n = this.getErrorTranslationKeyForHttpStatus(error.status);
-            if (error.error?.errorCode && error.error.errorCode in this.backendErrorCodes)
-                i18n = 'ERROR.' + error.error.errorCode;
-            this.notificationService.add('qdPanel', { type: 'critical', i18n, showAsSnackbar: true });
+            const isBlacklisted = this.blacklistErrorCodes.includes(error.status);
+            const shouldShowNotification = isBlacklisted || !this.whitelistErrorCodes.includes(error.status);
+            if (shouldShowNotification) {
+                let i18n = this.getErrorTranslationKeyForHttpStatus(error.status);
+                if (error.error?.errorCode && error.error.errorCode in this.backendErrorCodes)
+                    i18n = 'ERROR.' + error.error.errorCode;
+                this.notificationService.add('qdPanel', { type: 'critical', i18n, showAsSnackbar: true });
+            }
             return throwError(() => error);
         }));
     }
@@ -57,7 +84,7 @@ export class QdNotificationsHttpInterceptorService {
                 return 'UnknownError';
         }
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdNotificationsHttpInterceptorService, deps: [{ token: APP_ENVIRONMENT, optional: true }, { token: BACKEND_ERROR_CODES, optional: true }, { token: i1.QdNotificationsService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdNotificationsHttpInterceptorService, deps: [{ token: APP_ENVIRONMENT, optional: true }, { token: BACKEND_ERROR_CODES, optional: true }, { token: WHITELIST_ERROR_CODES, optional: true }, { token: i1.QdNotificationsService }], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdNotificationsHttpInterceptorService, providedIn: 'root' });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdNotificationsHttpInterceptorService, decorators: [{
@@ -75,5 +102,10 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImpor
                 }, {
                     type: Inject,
                     args: [BACKEND_ERROR_CODES]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [WHITELIST_ERROR_CODES]
                 }] }, { type: i1.QdNotificationsService }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"notifications-http-interceptor.service.js","sourceRoot":"","sources":["../../../../../../libs/qd-ui/src/lib/notifications/services/notifications-http-interceptor.service.ts"],"names":[],"mappings":"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","sourcesContent":["// @ts-strict-ignore\nimport { Inject, Injectable, InjectionToken, Optional } from '@angular/core';\nimport {\n  HttpErrorResponse,\n  HttpEvent,\n  HttpHandler,\n  HttpInterceptor,\n  HttpRequest,\n  HttpStatusCode\n} from '@angular/common/http';\nimport { Observable, throwError } from 'rxjs';\nimport { catchError } from 'rxjs/operators';\nimport { constantCase } from '../../core/tools/constantCase.tools';\nimport { lowerFirst } from 'lodash';\n\nimport { APP_ENVIRONMENT } from '../../core/model/app-enviroment.token';\nimport { QdAppEnvironment } from '../../core/model/app-enviroment.interface';\nimport { QdNotificationsService } from './notifications-service.service';\n\nexport const BACKEND_ERROR_CODES = new InjectionToken('BACKEND_ERROR_CODES');\nexport const WHITELIST_ERROR_CODES = new InjectionToken<number[]>('WHITELIST_ERROR_CODES');\n\n/**\n * The QdNotificationsHttpInterceptorService is an Angular HTTP interceptor that captures error responses from HTTP requests and generates notifications for backend errors. This Service not only intercepts error responses, but it also handles specific error codes and translates them into appropriate error messages for display.\n */\n@Injectable({\n  providedIn: 'root'\n})\nexport class QdNotificationsHttpInterceptorService implements HttpInterceptor {\n  private readonly blacklistErrorCodes: number[];\n\n  constructor(\n    @Optional() @Inject(APP_ENVIRONMENT) private readonly appEnvironment: QdAppEnvironment,\n    @Optional() @Inject(BACKEND_ERROR_CODES) private readonly backendErrorCodes,\n    @Optional() @Inject(WHITELIST_ERROR_CODES) private readonly whitelistErrorCodes: number[],\n    public readonly notificationService: QdNotificationsService\n  ) {\n    this.backendErrorCodes = this.backendErrorCodes || {};\n    this.whitelistErrorCodes = this.whitelistErrorCodes || [];\n\n    this.blacklistErrorCodes = [\n      // 401, 402, 403\n      HttpStatusCode.Unauthorized,\n      HttpStatusCode.PaymentRequired,\n      HttpStatusCode.Forbidden,\n      // All 5xx codes\n      HttpStatusCode.InternalServerError,\n      HttpStatusCode.NotImplemented,\n      HttpStatusCode.BadGateway,\n      HttpStatusCode.ServiceUnavailable,\n      HttpStatusCode.GatewayTimeout,\n      HttpStatusCode.HttpVersionNotSupported,\n      HttpStatusCode.VariantAlsoNegotiates,\n      HttpStatusCode.InsufficientStorage,\n      HttpStatusCode.LoopDetected,\n      HttpStatusCode.NotExtended,\n      HttpStatusCode.NetworkAuthenticationRequired\n    ];\n  }\n\n  intercept(request: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {\n    if (this.appEnvironment.disableBackendNotifications) return next.handle(request);\n\n    return next.handle(request).pipe(\n      catchError((error: HttpErrorResponse) => {\n        const isBlacklisted = this.blacklistErrorCodes.includes(error.status);\n        const shouldShowNotification = isBlacklisted || !this.whitelistErrorCodes.includes(error.status);\n\n        if (shouldShowNotification) {\n          let i18n = this.getErrorTranslationKeyForHttpStatus(error.status);\n\n          if (error.error?.errorCode && error.error.errorCode in this.backendErrorCodes)\n            i18n = 'ERROR.' + error.error.errorCode;\n\n          this.notificationService.add('qdPanel', { type: 'critical', i18n, showAsSnackbar: true });\n        }\n\n        return throwError(() => error);\n      })\n    );\n  }\n\n  private getErrorTranslationKeyForHttpStatus(httpStatusCode: HttpStatusCode): string {\n    const httpErrorName = this.getHttpErrorName(httpStatusCode);\n\n    return this.backendErrorCodes[`HTTP_${constantCase(httpErrorName)}`]\n      ? `Error.HTTP_${constantCase(httpErrorName)}`\n      : `i18n.qd.notification.error.${lowerFirst(httpErrorName).replace('Error', '')}`;\n  }\n\n  private getHttpErrorName(httpStatusCode: HttpStatusCode): string {\n    switch (httpStatusCode) {\n      case HttpStatusCode.BadRequest:\n        return 'BadRequest';\n      case HttpStatusCode.Unauthorized:\n        return 'Unauthorized';\n      case HttpStatusCode.Forbidden:\n        return 'Forbidden';\n      case HttpStatusCode.NotFound:\n        return 'NotFound';\n      default:\n        if (httpStatusCode >= 500) {\n          return 'ServerError';\n        }\n        return 'UnknownError';\n    }\n  }\n}\n"]}

package/esm2022/lib/qd-ui.module.mjs

@@ -1,6 +1,6 @@
 import { HTTP_INTERCEPTORS } from '@angular/common/http';
 import { NgModule } from '@angular/core';
-import { BACKEND_ERROR_CODES, QdNotificationsHttpInterceptorService } from './notifications/services/notifications-http-interceptor.service';
+import { BACKEND_ERROR_CODES, WHITELIST_ERROR_CODES, QdNotificationsHttpInterceptorService } from './notifications/services/notifications-http-interceptor.service';
 import { APP_ENVIRONMENT } from './core/model/app-enviroment.token';
 import { QdButtonModule } from './button/button.module';
 import { QdChipModule } from './chips/chips.module';
@@ -83,12 +83,13 @@ const QD_UI_MODULES = [
     QdTreeModule
 ];
 export class QdUiModule {
-    static forRoot(config, backendErrorCodes = {}) {
+    static forRoot(config, backendErrorCodes = {}, whitelistErrorCodes = []) {
         return {
             ngModule: QdUiModule,
             providers: [
                 { provide: APP_ENVIRONMENT, useValue: config },
-                { provide: BACKEND_ERROR_CODES, useValue: backendErrorCodes }
+                { provide: BACKEND_ERROR_CODES, useValue: backendErrorCodes },
+                { provide: WHITELIST_ERROR_CODES, useValue: whitelistErrorCodes }
             ]
         };
     }
@@ -229,4 +230,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImpor
                     ]
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"qd-ui.module.js","sourceRoot":"","sources":["../../../../libs/qd-ui/src/lib/qd-ui.module.ts"],"names":[],"mappings":"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","sourcesContent":["import { HTTP_INTERCEPTORS } from '@angular/common/http';\nimport { ModuleWithProviders, NgModule } from '@angular/core';\n\nimport {\n  BACKEND_ERROR_CODES,\n  QdNotificationsHttpInterceptorService\n} from './notifications/services/notifications-http-interceptor.service';\n\nimport { QdAppEnvironment } from './core/model/app-enviroment.interface';\nimport { APP_ENVIRONMENT } from './core/model/app-enviroment.token';\n\nimport { QdButtonModule } from './button/button.module';\nimport { QdChipModule } from './chips/chips.module';\nimport { QdCommentsModule } from './comments/comments.module';\nimport { QdContactCardModule } from './contact-card/contact-card.module';\nimport { QdContainerModule } from './container/container.module';\nimport { QdContentGridModule } from './content-grid/content-grid.module';\nimport { QdCoreModule } from './core/core.module';\nimport { QdDialogModule } from './dialog/dialog.module';\nimport { QdFileCollectorModule } from './file-collector/file-collector.module';\nimport { QdFilterModule } from './filter/filter.module';\nimport { QdFormModule } from './forms/qd-form.module';\nimport { QdGridModule } from './grid/grid.module';\nimport { QdIconModule } from './icon/icon.module';\nimport { QdImageModule } from './image/image.module';\nimport { QdLayoutModule } from './layout/layout.module';\nimport { QdListModule } from './lists/list.module';\nimport { QdMasterLayoutModule } from './master-layout/master-layout.module';\nimport { QdMasterLayoutService } from './master-layout/service/master-layout.service';\nimport { QdNavigationTilesModule } from './navigation-tiles/navigation-tiles.module';\nimport { QdNotificationsModule } from './notifications/notifications.module';\nimport { QdPageModule } from './page/page.module';\nimport { QdPageStepperModule } from './page-stepper/page-stepper.module';\nimport { QdPageTabsModule } from './page-tabs/page-tabs.module';\nimport { QdPlaceHolderModule } from './place-holder/place-holder.module';\nimport { QdProgressBarModule } from './progress-bar/progress-bar.module';\nimport { QdQuickEditModule } from './quick-edit/quick-edit.module';\nimport { QdSearchModule } from './search/search.module';\nimport { QdSectionModule } from './section/section.module';\nimport { QdShellModule } from './shell/shell.module';\nimport { QdSpinnerModule } from './spinner/spinner.module';\nimport { QdStatusIndicatorModule } from './status-indicator/status-indicator.module';\nimport { QdStepperModule } from './navigation/stepper/stepper.module';\nimport { QdTabBarModule } from './navigation/tab-bar/tab-bar.module';\nimport { QdTableModule } from './table/table.module';\nimport { QdTabsModule } from './navigation/tabs/tabs.module';\nimport { QdTextSectionModule } from './text-section/text-section.module';\nimport { QdTilesModule } from './tiles/tiles.module';\nimport { QdTreeModule } from './tree/tree.module';\nimport { QdPanelSectionModule } from './panel-section/panel-section.module';\n\nconst QD_UI_MODULES = [\n  QdButtonModule,\n  QdChipModule,\n  QdCommentsModule,\n  QdContactCardModule,\n  QdContainerModule,\n  QdContentGridModule,\n  QdCoreModule,\n  QdDialogModule,\n  QdFileCollectorModule,\n  QdFilterModule,\n  QdFormModule,\n  QdGridModule,\n  QdIconModule,\n  QdImageModule,\n  QdLayoutModule,\n  QdListModule,\n  QdMasterLayoutModule,\n  QdNavigationTilesModule,\n  QdNotificationsModule,\n  QdPageModule,\n  QdPageStepperModule,\n  QdPageTabsModule,\n  QdPanelSectionModule,\n  QdPlaceHolderModule,\n  QdProgressBarModule,\n  QdQuickEditModule,\n  QdSearchModule,\n  QdSectionModule,\n  QdShellModule,\n  QdSpinnerModule,\n  QdStatusIndicatorModule,\n  QdStepperModule,\n  QdTabBarModule,\n  QdTableModule,\n  QdTabsModule,\n  QdTextSectionModule,\n  QdTilesModule,\n  QdTreeModule\n];\n\n@NgModule({\n  imports: [QD_UI_MODULES],\n  exports: QD_UI_MODULES,\n  providers: [\n    QdMasterLayoutService,\n    {\n      provide: HTTP_INTERCEPTORS,\n      useClass: QdNotificationsHttpInterceptorService,\n      multi: true\n    }\n  ]\n})\nexport class QdUiModule {\n  static forRoot(config: QdAppEnvironment, backendErrorCodes = {}): ModuleWithProviders<QdUiModule> {\n    return {\n      ngModule: QdUiModule,\n      providers: [\n        { provide: APP_ENVIRONMENT, useValue: config },\n        { provide: BACKEND_ERROR_CODES, useValue: backendErrorCodes }\n      ]\n    };\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"qd-ui.module.js","sourceRoot":"","sources":["../../../../libs/qd-ui/src/lib/qd-ui.module.ts"],"names":[],"mappings":"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","sourcesContent":["import { HTTP_INTERCEPTORS } from '@angular/common/http';\nimport { ModuleWithProviders, NgModule } from '@angular/core';\n\nimport {\n  BACKEND_ERROR_CODES,\n  WHITELIST_ERROR_CODES,\n  QdNotificationsHttpInterceptorService\n} from './notifications/services/notifications-http-interceptor.service';\n\nimport { QdAppEnvironment } from './core/model/app-enviroment.interface';\nimport { APP_ENVIRONMENT } from './core/model/app-enviroment.token';\n\nimport { QdButtonModule } from './button/button.module';\nimport { QdChipModule } from './chips/chips.module';\nimport { QdCommentsModule } from './comments/comments.module';\nimport { QdContactCardModule } from './contact-card/contact-card.module';\nimport { QdContainerModule } from './container/container.module';\nimport { QdContentGridModule } from './content-grid/content-grid.module';\nimport { QdCoreModule } from './core/core.module';\nimport { QdDialogModule } from './dialog/dialog.module';\nimport { QdFileCollectorModule } from './file-collector/file-collector.module';\nimport { QdFilterModule } from './filter/filter.module';\nimport { QdFormModule } from './forms/qd-form.module';\nimport { QdGridModule } from './grid/grid.module';\nimport { QdIconModule } from './icon/icon.module';\nimport { QdImageModule } from './image/image.module';\nimport { QdLayoutModule } from './layout/layout.module';\nimport { QdListModule } from './lists/list.module';\nimport { QdMasterLayoutModule } from './master-layout/master-layout.module';\nimport { QdMasterLayoutService } from './master-layout/service/master-layout.service';\nimport { QdNavigationTilesModule } from './navigation-tiles/navigation-tiles.module';\nimport { QdNotificationsModule } from './notifications/notifications.module';\nimport { QdPageModule } from './page/page.module';\nimport { QdPageStepperModule } from './page-stepper/page-stepper.module';\nimport { QdPageTabsModule } from './page-tabs/page-tabs.module';\nimport { QdPlaceHolderModule } from './place-holder/place-holder.module';\nimport { QdProgressBarModule } from './progress-bar/progress-bar.module';\nimport { QdQuickEditModule } from './quick-edit/quick-edit.module';\nimport { QdSearchModule } from './search/search.module';\nimport { QdSectionModule } from './section/section.module';\nimport { QdShellModule } from './shell/shell.module';\nimport { QdSpinnerModule } from './spinner/spinner.module';\nimport { QdStatusIndicatorModule } from './status-indicator/status-indicator.module';\nimport { QdStepperModule } from './navigation/stepper/stepper.module';\nimport { QdTabBarModule } from './navigation/tab-bar/tab-bar.module';\nimport { QdTableModule } from './table/table.module';\nimport { QdTabsModule } from './navigation/tabs/tabs.module';\nimport { QdTextSectionModule } from './text-section/text-section.module';\nimport { QdTilesModule } from './tiles/tiles.module';\nimport { QdTreeModule } from './tree/tree.module';\nimport { QdPanelSectionModule } from './panel-section/panel-section.module';\n\nconst QD_UI_MODULES = [\n  QdButtonModule,\n  QdChipModule,\n  QdCommentsModule,\n  QdContactCardModule,\n  QdContainerModule,\n  QdContentGridModule,\n  QdCoreModule,\n  QdDialogModule,\n  QdFileCollectorModule,\n  QdFilterModule,\n  QdFormModule,\n  QdGridModule,\n  QdIconModule,\n  QdImageModule,\n  QdLayoutModule,\n  QdListModule,\n  QdMasterLayoutModule,\n  QdNavigationTilesModule,\n  QdNotificationsModule,\n  QdPageModule,\n  QdPageStepperModule,\n  QdPageTabsModule,\n  QdPanelSectionModule,\n  QdPlaceHolderModule,\n  QdProgressBarModule,\n  QdQuickEditModule,\n  QdSearchModule,\n  QdSectionModule,\n  QdShellModule,\n  QdSpinnerModule,\n  QdStatusIndicatorModule,\n  QdStepperModule,\n  QdTabBarModule,\n  QdTableModule,\n  QdTabsModule,\n  QdTextSectionModule,\n  QdTilesModule,\n  QdTreeModule\n];\n\n@NgModule({\n  imports: [QD_UI_MODULES],\n  exports: QD_UI_MODULES,\n  providers: [\n    QdMasterLayoutService,\n    {\n      provide: HTTP_INTERCEPTORS,\n      useClass: QdNotificationsHttpInterceptorService,\n      multi: true\n    }\n  ]\n})\nexport class QdUiModule {\n  static forRoot(\n    config: QdAppEnvironment,\n    backendErrorCodes = {},\n    whitelistErrorCodes: number[] = []\n  ): ModuleWithProviders<QdUiModule> {\n    return {\n      ngModule: QdUiModule,\n      providers: [\n        { provide: APP_ENVIRONMENT, useValue: config },\n        { provide: BACKEND_ERROR_CODES, useValue: backendErrorCodes },\n        { provide: WHITELIST_ERROR_CODES, useValue: whitelistErrorCodes }\n      ]\n    };\n  }\n}\n"]}

package/fesm2022/quadrel-ui-qd-ui.mjs

@@ -1700,27 +1700,54 @@ const APP_ENVIRONMENT = new InjectionToken('APP_ENVIRONMENT');
 
 // @ts-strict-ignore
 const BACKEND_ERROR_CODES = new InjectionToken('BACKEND_ERROR_CODES');
+const WHITELIST_ERROR_CODES = new InjectionToken('WHITELIST_ERROR_CODES');
 /**
  * The QdNotificationsHttpInterceptorService is an Angular HTTP interceptor that captures error responses from HTTP requests and generates notifications for backend errors. This Service not only intercepts error responses, but it also handles specific error codes and translates them into appropriate error messages for display.
  */
 class QdNotificationsHttpInterceptorService {
     appEnvironment;
     backendErrorCodes;
+    whitelistErrorCodes;
     notificationService;
-    constructor(appEnvironment, backendErrorCodes, notificationService) {
+    blacklistErrorCodes;
+    constructor(appEnvironment, backendErrorCodes, whitelistErrorCodes, notificationService) {
         this.appEnvironment = appEnvironment;
         this.backendErrorCodes = backendErrorCodes;
+        this.whitelistErrorCodes = whitelistErrorCodes;
         this.notificationService = notificationService;
         this.backendErrorCodes = this.backendErrorCodes || {};
+        this.whitelistErrorCodes = this.whitelistErrorCodes || [];
+        this.blacklistErrorCodes = [
+            // 401, 402, 403
+            HttpStatusCode.Unauthorized,
+            HttpStatusCode.PaymentRequired,
+            HttpStatusCode.Forbidden,
+            // All 5xx codes
+            HttpStatusCode.InternalServerError,
+            HttpStatusCode.NotImplemented,
+            HttpStatusCode.BadGateway,
+            HttpStatusCode.ServiceUnavailable,
+            HttpStatusCode.GatewayTimeout,
+            HttpStatusCode.HttpVersionNotSupported,
+            HttpStatusCode.VariantAlsoNegotiates,
+            HttpStatusCode.InsufficientStorage,
+            HttpStatusCode.LoopDetected,
+            HttpStatusCode.NotExtended,
+            HttpStatusCode.NetworkAuthenticationRequired
+        ];
     }
     intercept(request, next) {
         if (this.appEnvironment.disableBackendNotifications)
             return next.handle(request);
         return next.handle(request).pipe(catchError((error) => {
-            let i18n = this.getErrorTranslationKeyForHttpStatus(error.status);
-            if (error.error?.errorCode && error.error.errorCode in this.backendErrorCodes)
-                i18n = 'ERROR.' + error.error.errorCode;
-            this.notificationService.add('qdPanel', { type: 'critical', i18n, showAsSnackbar: true });
+            const isBlacklisted = this.blacklistErrorCodes.includes(error.status);
+            const shouldShowNotification = isBlacklisted || !this.whitelistErrorCodes.includes(error.status);
+            if (shouldShowNotification) {
+                let i18n = this.getErrorTranslationKeyForHttpStatus(error.status);
+                if (error.error?.errorCode && error.error.errorCode in this.backendErrorCodes)
+                    i18n = 'ERROR.' + error.error.errorCode;
+                this.notificationService.add('qdPanel', { type: 'critical', i18n, showAsSnackbar: true });
+            }
             return throwError(() => error);
         }));
     }
@@ -1747,7 +1774,7 @@ class QdNotificationsHttpInterceptorService {
                 return 'UnknownError';
         }
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdNotificationsHttpInterceptorService, deps: [{ token: APP_ENVIRONMENT, optional: true }, { token: BACKEND_ERROR_CODES, optional: true }, { token: QdNotificationsService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdNotificationsHttpInterceptorService, deps: [{ token: APP_ENVIRONMENT, optional: true }, { token: BACKEND_ERROR_CODES, optional: true }, { token: WHITELIST_ERROR_CODES, optional: true }, { token: QdNotificationsService }], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdNotificationsHttpInterceptorService, providedIn: 'root' });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdNotificationsHttpInterceptorService, decorators: [{
@@ -1765,6 +1792,11 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImpor
                 }, {
                     type: Inject,
                     args: [BACKEND_ERROR_CODES]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [WHITELIST_ERROR_CODES]
                 }] }, { type: QdNotificationsService }] });
 
 // @ts-strict-ignore
@@ -16961,6 +16993,42 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImpor
  * }
  * ```
  *
+ * ### Whitelisting HTTP status codes
+ *
+ * In some cases, you might want to prevent certain HTTP status codes from triggering error notifications. For example, a 304 Not Modified response is not actually an error and should not display an error notification. The **QdUiModule** allows you to whitelist specific HTTP status codes.
+ *
+ * To whitelist HTTP status codes, pass an array of status codes as the third parameter to the **QdUiModule.forRoot** method:
+ *
+ * ```typescript
+ * import { HttpStatusCode } from '@angular/common/http';
+ *
+ * imports: [
+ *   ...
+ *   QdUiModule.forRoot(
+ *     appEnvironment,
+ *     ErrorCodes,
+ *     [HttpStatusCode.NotModified, HttpStatusCode.NoContent] // Whitelist 304 Not Modified and 204 No Content
+ *   ),
+ *   ...
+ * ]
+ * ```
+ *
+ * When a response with a whitelisted status code is received, no error notification will be displayed, even if it would normally be treated as an error by the HTTP client.
+ *
+ * ### Blacklisting HTTP status codes
+ *
+ * For critical errors, notifications are always shown, even if the status code is whitelisted. The **QdUiModule** implements a fixed blacklist that takes precedence over the whitelist.
+ *
+ * The following status codes are permanently blacklisted:
+ * - 401 Unauthorized
+ * - 402 Payment Required
+ * - 403 Forbidden
+ * - All 5xx server error codes (500-511)
+ *
+ * These critical errors will always show notifications, even if they are included in the whitelist.
+ *
+ * **Important**: The blacklist has higher precedence than the whitelist. If a status code appears in both the whitelist and the blacklist, it will be treated as blacklisted, and an error notification will be shown.
+ *
  * ### Component:
  *
  * ```typescript
@@ -37736,12 +37804,13 @@ const QD_UI_MODULES = [
     QdTreeModule
 ];
 class QdUiModule {
-    static forRoot(config, backendErrorCodes = {}) {
+    static forRoot(config, backendErrorCodes = {}, whitelistErrorCodes = []) {
         return {
             ngModule: QdUiModule,
             providers: [
                 { provide: APP_ENVIRONMENT, useValue: config },
-                { provide: BACKEND_ERROR_CODES, useValue: backendErrorCodes }
+                { provide: BACKEND_ERROR_CODES, useValue: backendErrorCodes },
+                { provide: WHITELIST_ERROR_CODES, useValue: whitelistErrorCodes }
             ]
         };
     }