@kolektor/nucleus-notifications 0.0.12-pre.7931 → 0.1.130-pre.1

package/README.md

@@ -0,0 +1,7 @@
+# nucleus-notifications
+
+This library was generated with [Nx](https://nx.dev).
+
+## Running unit tests
+
+Run `nx test nucleus-notifications` to execute the unit tests.

package/esm2022/index.mjs

@@ -0,0 +1,4 @@
+export * from './lib/nucleus-notifications.service';
+export * from './lib/nucleus-notifications.module';
+export * from './lib/models';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL25nL251Y2xldXMvbnVjbGV1cy1ub3RpZmljYXRpb25zL3NyYy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHFDQUFxQyxDQUFDO0FBQ3BELGNBQWMsb0NBQW9DLENBQUM7QUFDbkQsY0FBYyxjQUFjLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2xpYi9udWNsZXVzLW5vdGlmaWNhdGlvbnMuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9udWNsZXVzLW5vdGlmaWNhdGlvbnMubW9kdWxlJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL21vZGVscyc7XG4iXX0=

package/esm2022/kolektor-nucleus-notifications.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoia29sZWt0b3ItbnVjbGV1cy1ub3RpZmljYXRpb25zLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9uZy9udWNsZXVzL251Y2xldXMtbm90aWZpY2F0aW9ucy9zcmMva29sZWt0b3ItbnVjbGV1cy1ub3RpZmljYXRpb25zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyxTQUFTLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEdlbmVyYXRlZCBidW5kbGUgaW5kZXguIERvIG5vdCBlZGl0LlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vaW5kZXgnO1xuIl19

package/esm2022/lib/models.mjs

@@ -0,0 +1,23 @@
+export class Notification {
+}
+export class Identity {
+}
+export class Recipient {
+}
+export class NotificationData {
+}
+export class WebKey {
+}
+export class Registration {
+}
+export class RegistrationResult {
+}
+export class PayloadData {
+}
+export class NucleusNotificationsConfig {
+}
+export class NotificationClick {
+}
+export class UserChannelConfig {
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/nucleus-notifications.module.mjs

@@ -0,0 +1,23 @@
+import { NgModule } from '@angular/core';
+import { NucleusNotificationsConfig } from './models';
+import * as i0 from "@angular/core";
+export class NucleusNotificationsModule {
+    static forRoot(config) {
+        return {
+            ngModule: NucleusNotificationsModule,
+            providers: [{ provide: NucleusNotificationsConfig, useValue: config }],
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: NucleusNotificationsModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.2.12", ngImport: i0, type: NucleusNotificationsModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: NucleusNotificationsModule }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: NucleusNotificationsModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [],
+                    imports: [],
+                    exports: [],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibnVjbGV1cy1ub3RpZmljYXRpb25zLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvbmcvbnVjbGV1cy9udWNsZXVzLW5vdGlmaWNhdGlvbnMvc3JjL2xpYi9udWNsZXVzLW5vdGlmaWNhdGlvbnMubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQXVCLE1BQU0sZUFBZSxDQUFDO0FBQzlELE9BQU8sRUFBRSwwQkFBMEIsRUFBRSxNQUFNLFVBQVUsQ0FBQzs7QUFPdEQsTUFBTSxPQUFPLDBCQUEwQjtJQUNyQyxNQUFNLENBQUMsT0FBTyxDQUNaLE1BQWtDO1FBRWxDLE9BQU87WUFDTCxRQUFRLEVBQUUsMEJBQTBCO1lBQ3BDLFNBQVMsRUFBRSxDQUFDLEVBQUUsT0FBTyxFQUFFLDBCQUEwQixFQUFFLFFBQVEsRUFBRSxNQUFNLEVBQUUsQ0FBQztTQUN2RSxDQUFDO0lBQ0osQ0FBQzsrR0FSVSwwQkFBMEI7Z0hBQTFCLDBCQUEwQjtnSEFBMUIsMEJBQTBCOzs0RkFBMUIsMEJBQTBCO2tCQUx0QyxRQUFRO21CQUFDO29CQUNSLFlBQVksRUFBRSxFQUFFO29CQUNoQixPQUFPLEVBQUUsRUFBRTtvQkFDWCxPQUFPLEVBQUUsRUFBRTtpQkFDWiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE5nTW9kdWxlLCBNb2R1bGVXaXRoUHJvdmlkZXJzIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBOdWNsZXVzTm90aWZpY2F0aW9uc0NvbmZpZyB9IGZyb20gJy4vbW9kZWxzJztcblxuQE5nTW9kdWxlKHtcbiAgZGVjbGFyYXRpb25zOiBbXSxcbiAgaW1wb3J0czogW10sXG4gIGV4cG9ydHM6IFtdLFxufSlcbmV4cG9ydCBjbGFzcyBOdWNsZXVzTm90aWZpY2F0aW9uc01vZHVsZSB7XG4gIHN0YXRpYyBmb3JSb290KFxuICAgIGNvbmZpZzogTnVjbGV1c05vdGlmaWNhdGlvbnNDb25maWdcbiAgKTogTW9kdWxlV2l0aFByb3ZpZGVyczxOdWNsZXVzTm90aWZpY2F0aW9uc01vZHVsZT4ge1xuICAgIHJldHVybiB7XG4gICAgICBuZ01vZHVsZTogTnVjbGV1c05vdGlmaWNhdGlvbnNNb2R1bGUsXG4gICAgICBwcm92aWRlcnM6IFt7IHByb3ZpZGU6IE51Y2xldXNOb3RpZmljYXRpb25zQ29uZmlnLCB1c2VWYWx1ZTogY29uZmlnIH1dLFxuICAgIH07XG4gIH1cbn1cbiJdfQ==

package/esm2022/lib/nucleus-notifications.service.mjs

@@ -0,0 +1,387 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { HttpClient } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { SwPush } from '@angular/service-worker';
+import { PushNotifications, } from '@capacitor/push-notifications';
+import { NucleusAppService } from '@kolektor/nucleus-common';
+import { of, Subject } from 'rxjs';
+import { NucleusNotificationsConfig, } from './models';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "@angular/service-worker";
+import * as i3 from "@kolektor/nucleus-common";
+import * as i4 from "./models";
+export class NucleusNotificationsService {
+    constructor(http, swPush, appService, config) {
+        this.http = http;
+        this.swPush = swPush;
+        this.appService = appService;
+        this.registrationStorageKey = 'NucleusNotificationsRegistrationId';
+        this.notificationsStorageKey = 'NucleusNotificationsLocalCache';
+        this._isInitialized = false;
+        this._newNotifications = new Subject();
+        this._clicksSubject = new Subject();
+        this._stateChangesSubject = new Subject();
+        this.notifications = [];
+        let url = config.serverApiUrl;
+        if (!url.endsWith('/')) {
+            url += '/';
+        }
+        this.apiUrl = url;
+    }
+    get unreadCount() {
+        return this.notifications.filter((x) => !x.isRead).length;
+    }
+    get newNotifications() {
+        return this._newNotifications.asObservable();
+    }
+    get clicks() {
+        return this._clicksSubject.asObservable();
+    }
+    get stateChanges() {
+        return this._stateChangesSubject.asObservable();
+    }
+    get isInitialized() {
+        return this._isInitialized;
+    }
+    async initialize() {
+        // make sure app service has finished initializing
+        await this.appService.init();
+        this.loadFromStorage();
+        if (this.appService.isNative) {
+            this._platform = this.appService.deviceInfo.platform;
+            await this.registerCapacitorEvents();
+        }
+        else if (this.swPush.isEnabled) {
+            this._platform = 'web';
+            this.registerWebPushEvents();
+        }
+        else {
+            console.warn('Nucleus.Notifications: There is no push capability, timer will be used to update notifications');
+            setInterval(() => {
+                console.log('Updating notifications...');
+                this.refresh(true);
+            }, 5 * 60 * 1000);
+        }
+        this._isInitialized = true;
+        this.refresh();
+    }
+    register() {
+        return new Promise((_resolve, _reject) => {
+            this.getRegistrationInfo()
+                .then((info) => {
+                this.http
+                    .post(this.apiUrl + 'registration', info)
+                    .subscribe((regResult) => {
+                    window.localStorage.setItem(this.registrationStorageKey, regResult.id);
+                    _resolve(null);
+                }, (error) => {
+                    console.log('Nucleus.Notifications: Failed to send notification registration to server.', error);
+                    _reject(error);
+                });
+            })
+                .catch((error) => _reject(error));
+        });
+    }
+    unregister() {
+        return new Promise((_resolve, _reject) => {
+            this.getRegistrationInfo()
+                .then((info) => {
+                this.http
+                    .request('DELETE', this.apiUrl + 'registration', {
+                    body: info,
+                })
+                    .subscribe(() => {
+                    window.localStorage.removeItem(this.registrationStorageKey);
+                    _resolve(null);
+                }, (error) => {
+                    console.log('Nucleus.Notifications: Failed to remove registration from server.', error);
+                    _reject(error);
+                });
+            })
+                .catch((error) => _reject(error));
+        });
+    }
+    refresh(notifyAboutNew = false) {
+        this.http
+            .get(this.apiUrl + 'notifications')
+            .subscribe((res) => {
+            this.updateNotifications(res, notifyAboutNew);
+        });
+    }
+    getNotification(id) {
+        const localNotification = this.notifications.find((x) => x.id === id);
+        if (localNotification) {
+            return of(localNotification);
+        }
+        return this.http.get(this.apiUrl + 'notifications/' + id);
+    }
+    readNotification(id) {
+        const n = this.notifications.find((x) => x.id === id);
+        if (n && !n.isRead) {
+            n.isRead = true;
+            this.notifyStateChanged();
+        }
+        this.http.get(this.apiUrl + 'notifications/read/' + id).subscribe();
+    }
+    dismissNotification(id) {
+        this.deleteNotificaton(id);
+        this.http.delete(this.apiUrl + 'notifications/' + id).subscribe();
+        this.removeDeliveredNotification(id);
+    }
+    dismissAll() {
+        this.notifications.splice(0);
+        this.notifyStateChanged();
+        this.http.delete(this.apiUrl + 'notifications/all').subscribe();
+        if (this._platform === 'ios' || this._platform === 'android') {
+            PushNotifications.removeAllDeliveredNotifications();
+        }
+        else if (this._platform === 'web') {
+            // TODO: remove all web push notifications
+        }
+    }
+    readAll() {
+        for (const n of this.notifications) {
+            n.isRead = true;
+        }
+        this.notifyStateChanged();
+        this.http.get(this.apiUrl + 'notifications/read/all').subscribe();
+    }
+    getChannelConfig(senderId, channelId, language) {
+        return this.http.get(this.apiUrl +
+            `settings/channel/${senderId}/${channelId}?language=${language}`);
+    }
+    getChannelConfigsForSender(senderId, channelIds, language) {
+        const idsStr = channelIds.map((x) => senderId + ',' + x).join(';');
+        return this.getChannelConfigsInternal(idsStr, language);
+    }
+    getChannelConfigs(ids, language) {
+        const idsStr = ids.map((x) => x.senderId + ',' + x.channelId).join(';');
+        return this.getChannelConfigsInternal(idsStr, language);
+    }
+    setChannelConfig(senderId, config) {
+        return this.http.post(`${this.apiUrl}settings/channel/${senderId}`, config);
+    }
+    setChannelConfigs(configs) {
+        return this.http.post(`${this.apiUrl}settings/channels`, configs);
+    }
+    getChannelConfigsInternal(ids, language) {
+        return this.http.get(`${this.apiUrl}settings/channels?ids=${ids}&language=${language}`);
+    }
+    updateNotifications(newNotifications, notifyAboutNew = false) {
+        let stateChanged = false;
+        for (const n of newNotifications) {
+            const existing = this.notifications.find((x) => x.id === n.id);
+            if (existing) {
+                if (existing.isRead !== n.isRead) {
+                    existing.isRead = n.isRead;
+                    stateChanged = true;
+                }
+            }
+            else {
+                let i = 0;
+                while (i < this.notifications.length &&
+                    n.dateCreated < this.notifications[i].dateCreated) {
+                    i++;
+                }
+                this.notifications.splice(i, 0, n);
+                stateChanged = true;
+                if (notifyAboutNew) {
+                    this._newNotifications.next(n);
+                }
+            }
+        }
+        const now = Date.now();
+        for (let i = this.notifications.length - 1; i >= 0; i--) {
+            const n = this.notifications[i];
+            if (new Date(n.expirationDate).getTime() < now ||
+                !newNotifications.find((x) => x.id === n.id)) {
+                this.notifications.splice(i, 1);
+                stateChanged = true;
+            }
+        }
+        if (stateChanged) {
+            this.notifyStateChanged();
+        }
+    }
+    saveToStorage() {
+        const str = JSON.stringify(this.notifications);
+        window.localStorage.setItem(this.notificationsStorageKey, str);
+    }
+    loadFromStorage() {
+        try {
+            const str = window.localStorage.getItem(this.notificationsStorageKey);
+            if (str) {
+                const notifications = JSON.parse(str);
+                this.notifications = notifications.filter((x) => !!x);
+                // precaution for notification.isRead of undefined error
+                this.notifyStateChanged(false);
+            }
+        }
+        catch {
+            /* empty */
+        }
+    }
+    handleNotificationEvent(id, eventType) {
+        if (eventType.startsWith('new') || eventType === 'updated') {
+            // we are handling new and newSilent
+            this.getNotification(id).subscribe((n) => {
+                if (eventType.startsWith('new') && !n.isRead) {
+                    this._newNotifications.next(n);
+                }
+                const existing = this.notifications.find((x) => x.id === n.id);
+                if (existing) {
+                    existing.isRead = n.isRead;
+                }
+                else {
+                    this.notifications.splice(0, 0, n);
+                }
+                this.notifyStateChanged();
+            });
+        }
+        else if (eventType === 'deleted') {
+            this.deleteNotificaton(id);
+        }
+        else {
+            this.refresh();
+        }
+    }
+    deleteNotificaton(id) {
+        const i = this.notifications.findIndex((x) => x.id === id);
+        if (i >= 0) {
+            this.notifications.splice(i, 1);
+            this.notifyStateChanged();
+        }
+    }
+    notifyStateChanged(persistState = true) {
+        if (persistState) {
+            this.saveToStorage();
+        }
+        this._stateChangesSubject.next();
+    }
+    handleNotificationAction(notificationAction) {
+        if (!notificationAction) {
+            throw new Error('Notification action is empty!');
+        }
+        const arr = notificationAction.split(':');
+        const notificationClick = {
+            id: arr[0],
+            type: arr[1],
+            routerLink: arr[2],
+        };
+        const validNotificationClickTypes = ['default', 'deeplink'];
+        if (validNotificationClickTypes.includes(notificationClick.type)) {
+            this._clicksSubject.next(notificationClick);
+        }
+        else {
+            console.error(`Nucleus.Notifications: Unknown notification action: '${notificationAction}'.`);
+        }
+    }
+    removeDeliveredNotification(id) {
+        if (this._platform === 'ios' || this._platform === 'android') {
+            PushNotifications.getDeliveredNotifications().then((list) => {
+                const toRemove = list.notifications.filter((n) => {
+                    const data = this.getNotificationPayloadData(n);
+                    return data.notificationId === id;
+                });
+                // TODO: On Android this does not currently work because notificationID is not set.
+                // This my solve the issue: https://github.com/ionic-team/capacitor/pull/3523
+                PushNotifications.removeDeliveredNotifications({
+                    notifications: toRemove,
+                });
+            });
+        }
+        else if (this._platform === 'web') {
+            // TODO: remove web push notification
+        }
+    }
+    getNotificationPayloadData(pushNotification) {
+        return this._platform === 'ios'
+            ? pushNotification.data.data
+            : pushNotification.data;
+    }
+    async registerCapacitorEvents() {
+        await PushNotifications.addListener('pushNotificationReceived', (n) => {
+            const data = this.getNotificationPayloadData(n);
+            console.log('Nucleus.Notifications: Received capacitor push event: ' +
+                data.eventType, n);
+            this.handleNotificationEvent(data.notificationId, data.eventType);
+        });
+        await PushNotifications.addListener('pushNotificationActionPerformed', (a) => {
+            let action = a.notification.data.notificationAction;
+            if (this._platform === 'ios') {
+                action = a.notification.data.data.notificationAction;
+            }
+            console.log('Nucleus.Notifications: Received capacitor action event', action);
+            this.handleNotificationAction(action);
+        });
+    }
+    registerWebPushEvents() {
+        this.swPush.messages.subscribe((n) => {
+            const data = n.data;
+            console.log('Nucleus.Notifications: Received WebPush event: ' + data.eventType, n);
+            this.handleNotificationEvent(data.notificationId, data.eventType);
+        });
+        this.swPush.notificationClicks.subscribe((action) => {
+            console.log('Nucleus.Notifications: Received WebPush action event', action);
+            const tag = action.notification.tag;
+            this.handleNotificationAction(tag);
+        });
+    }
+    getRegistrationInfo() {
+        return new Promise((_resolve, _reject) => {
+            const registrationId = window.localStorage.getItem(this.registrationStorageKey);
+            if (this._platform === 'android' || this._platform === 'ios') {
+                // capacitor platform
+                const listener = PushNotifications.addListener('registration', (token) => {
+                    listener.remove();
+                    _resolve({
+                        id: registrationId,
+                        token: token.value,
+                        platform: this._platform,
+                    });
+                });
+                PushNotifications.register().catch((error) => _reject('Could not register for notifications:' + error));
+            }
+            else if (this._platform === 'web') {
+                // Web Push API
+                this.http.get(this.apiUrl + 'registration/webkey').subscribe((key) => {
+                    this.getWebPushSubscription(key.publicKey).then((subscription) => {
+                        const t = JSON.stringify(subscription.toJSON());
+                        _resolve({ id: registrationId, token: t, platform: 'web' });
+                    });
+                }, (error) => _reject(error));
+            }
+            else {
+                _reject(`Nucleus.Notifications: Platform is not supported`);
+            }
+        });
+    }
+    getWebPushSubscription(publicKey) {
+        return new Promise((_resolve, _reject) => {
+            this.swPush.subscription.subscribe((subscription) => {
+                if (subscription != null) {
+                    _resolve(subscription);
+                }
+                else {
+                    this.swPush
+                        .requestSubscription({ serverPublicKey: publicKey })
+                        .then((s) => _resolve(s))
+                        .catch((e) => _reject(e));
+                }
+            }, (error) => {
+                console.error('Nucleus.Notifications: Cannot get web push subscription', error);
+                _reject(error);
+            });
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: NucleusNotificationsService, deps: [{ token: i1.HttpClient }, { token: i2.SwPush }, { token: i3.NucleusAppService }, { token: i4.NucleusNotificationsConfig }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: NucleusNotificationsService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: NucleusNotificationsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i2.SwPush }, { type: i3.NucleusAppService }, { type: i4.NucleusNotificationsConfig }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nucleus-notifications.service.js","sourceRoot":"","sources":["../../../../../../../libs/ng/nucleus/nucleus-notifications/src/lib/nucleus-notifications.service.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { HttpClient } from '@angular/common/http';\nimport { Injectable } from '@angular/core';\nimport { SwPush } from '@angular/service-worker';\nimport {\n  PushNotifications,\n  PushNotificationSchema,\n} from '@capacitor/push-notifications';\nimport { NucleusAppService } from '@kolektor/nucleus-common';\nimport { Observable, of, Subject } from 'rxjs';\nimport {\n  ChannelId,\n  Notification,\n  NotificationClick,\n  NotificationEventType,\n  NotificationType,\n  NucleusNotificationsConfig,\n  PayloadData,\n  PlatformValue,\n  Registration,\n  RegistrationResult,\n  UserChannelConfig,\n  WebKey,\n} from './models';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class NucleusNotificationsService {\n  constructor(\n    private http: HttpClient,\n    private swPush: SwPush,\n    private appService: NucleusAppService,\n    config: NucleusNotificationsConfig\n  ) {\n    let url = config.serverApiUrl;\n    if (!url.endsWith('/')) {\n      url += '/';\n    }\n    this.apiUrl = url;\n  }\n\n  private apiUrl: string;\n  private readonly registrationStorageKey =\n    'NucleusNotificationsRegistrationId';\n  private readonly notificationsStorageKey = 'NucleusNotificationsLocalCache';\n  private _platform: PlatformValue;\n  private _isInitialized = false;\n  private _newNotifications = new Subject<Notification>();\n  private _clicksSubject = new Subject<NotificationClick>();\n  private _stateChangesSubject = new Subject<void>();\n\n  public notifications: Notification[] = [];\n\n  public get unreadCount() {\n    return this.notifications.filter((x) => !x.isRead).length;\n  }\n\n  public get newNotifications() {\n    return this._newNotifications.asObservable();\n  }\n\n  public get clicks() {\n    return this._clicksSubject.asObservable();\n  }\n  public get stateChanges() {\n    return this._stateChangesSubject.asObservable();\n  }\n\n  public get isInitialized() {\n    return this._isInitialized;\n  }\n\n  public async initialize() {\n    // make sure app service has finished initializing\n    await this.appService.init();\n\n    this.loadFromStorage();\n\n    if (this.appService.isNative) {\n      this._platform = this.appService.deviceInfo.platform as PlatformValue;\n      await this.registerCapacitorEvents();\n    } else if (this.swPush.isEnabled) {\n      this._platform = 'web';\n      this.registerWebPushEvents();\n    } else {\n      console.warn(\n        'Nucleus.Notifications: There is no push capability, timer will be used to update notifications'\n      );\n      setInterval(() => {\n        console.log('Updating notifications...');\n        this.refresh(true);\n      }, 5 * 60 * 1000);\n    }\n    this._isInitialized = true;\n    this.refresh();\n  }\n\n  public register(): Promise<any> {\n    return new Promise((_resolve, _reject) => {\n      this.getRegistrationInfo()\n        .then((info) => {\n          this.http\n            .post<RegistrationResult>(this.apiUrl + 'registration', info)\n            .subscribe(\n              (regResult) => {\n                window.localStorage.setItem(\n                  this.registrationStorageKey,\n                  regResult.id\n                );\n                _resolve(null);\n              },\n              (error) => {\n                console.log(\n                  'Nucleus.Notifications: Failed to send notification registration to server.',\n                  error\n                );\n                _reject(error);\n              }\n            );\n        })\n        .catch((error) => _reject(error));\n    });\n  }\n\n  public unregister(): Promise<any> {\n    return new Promise((_resolve, _reject) => {\n      this.getRegistrationInfo()\n        .then((info) => {\n          this.http\n            .request<any>('DELETE', this.apiUrl + 'registration', {\n              body: info,\n            })\n            .subscribe(\n              () => {\n                window.localStorage.removeItem(this.registrationStorageKey);\n                _resolve(null);\n              },\n              (error) => {\n                console.log(\n                  'Nucleus.Notifications: Failed to remove registration from server.',\n                  error\n                );\n                _reject(error);\n              }\n            );\n        })\n        .catch((error) => _reject(error));\n    });\n  }\n\n  public refresh(notifyAboutNew = false) {\n    this.http\n      .get<Notification[]>(this.apiUrl + 'notifications')\n      .subscribe((res) => {\n        this.updateNotifications(res, notifyAboutNew);\n      });\n  }\n\n  public getNotification(id: string): Observable<Notification> {\n    const localNotification = this.notifications.find((x) => x.id === id);\n    if (localNotification) {\n      return of(localNotification);\n    }\n    return this.http.get<Notification>(this.apiUrl + 'notifications/' + id);\n  }\n\n  public readNotification(id: string) {\n    const n = this.notifications.find((x) => x.id === id);\n    if (n && !n.isRead) {\n      n.isRead = true;\n      this.notifyStateChanged();\n    }\n    this.http.get(this.apiUrl + 'notifications/read/' + id).subscribe();\n  }\n\n  public dismissNotification(id: string) {\n    this.deleteNotificaton(id);\n    this.http.delete(this.apiUrl + 'notifications/' + id).subscribe();\n    this.removeDeliveredNotification(id);\n  }\n\n  public dismissAll() {\n    this.notifications.splice(0);\n    this.notifyStateChanged();\n    this.http.delete(this.apiUrl + 'notifications/all').subscribe();\n    if (this._platform === 'ios' || this._platform === 'android') {\n      PushNotifications.removeAllDeliveredNotifications();\n    } else if (this._platform === 'web') {\n      // TODO: remove all web push notifications\n    }\n  }\n\n  public readAll() {\n    for (const n of this.notifications) {\n      n.isRead = true;\n    }\n    this.notifyStateChanged();\n    this.http.get(this.apiUrl + 'notifications/read/all').subscribe();\n  }\n\n  public getChannelConfig(\n    senderId: string,\n    channelId: string,\n    language?: string\n  ) {\n    return this.http.get<UserChannelConfig>(\n      this.apiUrl +\n        `settings/channel/${senderId}/${channelId}?language=${language}`\n    );\n  }\n\n  public getChannelConfigsForSender(\n    senderId: string,\n    channelIds: string[],\n    language?: string\n  ) {\n    const idsStr = channelIds.map((x) => senderId + ',' + x).join(';');\n    return this.getChannelConfigsInternal(idsStr, language);\n  }\n\n  public getChannelConfigs(ids: ChannelId[], language?: string) {\n    const idsStr = ids.map((x) => x.senderId + ',' + x.channelId).join(';');\n    return this.getChannelConfigsInternal(idsStr, language);\n  }\n\n  public setChannelConfig(senderId: string, config: UserChannelConfig) {\n    return this.http.post<void>(\n      `${this.apiUrl}settings/channel/${senderId}`,\n      config\n    );\n  }\n\n  public setChannelConfigs(configs: UserChannelConfig[]) {\n    return this.http.post<void>(`${this.apiUrl}settings/channels`, configs);\n  }\n\n  private getChannelConfigsInternal(ids: string, language?: string) {\n    return this.http.get<UserChannelConfig[]>(\n      `${this.apiUrl}settings/channels?ids=${ids}&language=${language}`\n    );\n  }\n\n  private updateNotifications(\n    newNotifications: Notification[],\n    notifyAboutNew = false\n  ) {\n    let stateChanged = false;\n    for (const n of newNotifications) {\n      const existing = this.notifications.find((x) => x.id === n.id);\n      if (existing) {\n        if (existing.isRead !== n.isRead) {\n          existing.isRead = n.isRead;\n          stateChanged = true;\n        }\n      } else {\n        let i = 0;\n        while (\n          i < this.notifications.length &&\n          n.dateCreated < this.notifications[i].dateCreated\n        ) {\n          i++;\n        }\n        this.notifications.splice(i, 0, n);\n        stateChanged = true;\n        if (notifyAboutNew) {\n          this._newNotifications.next(n);\n        }\n      }\n    }\n\n    const now = Date.now();\n    for (let i = this.notifications.length - 1; i >= 0; i--) {\n      const n = this.notifications[i];\n      if (\n        new Date(n.expirationDate).getTime() < now ||\n        !newNotifications.find((x) => x.id === n.id)\n      ) {\n        this.notifications.splice(i, 1);\n        stateChanged = true;\n      }\n    }\n\n    if (stateChanged) {\n      this.notifyStateChanged();\n    }\n  }\n\n  private saveToStorage() {\n    const str = JSON.stringify(this.notifications);\n    window.localStorage.setItem(this.notificationsStorageKey, str);\n  }\n\n  private loadFromStorage() {\n    try {\n      const str = window.localStorage.getItem(this.notificationsStorageKey);\n      if (str) {\n        const notifications = JSON.parse(str) as Notification[];\n        this.notifications = notifications.filter((x) => !!x);\n        // precaution for notification.isRead of undefined error\n        this.notifyStateChanged(false);\n      }\n    } catch {\n      /* empty */\n    }\n  }\n\n  private handleNotificationEvent(\n    id: string,\n    eventType: NotificationEventType\n  ) {\n    if (eventType.startsWith('new') || eventType === 'updated') {\n      // we are handling new and newSilent\n      this.getNotification(id).subscribe((n) => {\n        if (eventType.startsWith('new') && !n.isRead) {\n          this._newNotifications.next(n);\n        }\n        const existing = this.notifications.find((x) => x.id === n.id);\n        if (existing) {\n          existing.isRead = n.isRead;\n        } else {\n          this.notifications.splice(0, 0, n);\n        }\n        this.notifyStateChanged();\n      });\n    } else if (eventType === 'deleted') {\n      this.deleteNotificaton(id);\n    } else {\n      this.refresh();\n    }\n  }\n\n  private deleteNotificaton(id: string) {\n    const i = this.notifications.findIndex((x) => x.id === id);\n    if (i >= 0) {\n      this.notifications.splice(i, 1);\n      this.notifyStateChanged();\n    }\n  }\n\n  private notifyStateChanged(persistState = true) {\n    if (persistState) {\n      this.saveToStorage();\n    }\n    this._stateChangesSubject.next();\n  }\n\n  private handleNotificationAction(notificationAction: string | undefined) {\n    if (!notificationAction) {\n      throw new Error('Notification action is empty!');\n    }\n\n    const arr = notificationAction.split(':');\n    const notificationClick: NotificationClick = {\n      id: arr[0],\n      type: arr[1] as NotificationType,\n      routerLink: arr[2],\n    };\n\n    const validNotificationClickTypes = ['default', 'deeplink'];\n    if (validNotificationClickTypes.includes(notificationClick.type)) {\n      this._clicksSubject.next(notificationClick);\n    } else {\n      console.error(\n        `Nucleus.Notifications: Unknown notification action: '${notificationAction}'.`\n      );\n    }\n  }\n\n  private removeDeliveredNotification(id: string) {\n    if (this._platform === 'ios' || this._platform === 'android') {\n      PushNotifications.getDeliveredNotifications().then((list) => {\n        const toRemove = list.notifications.filter((n) => {\n          const data = this.getNotificationPayloadData(n);\n          return data.notificationId === id;\n        });\n\n        // TODO: On Android this does not currently work because notificationID is not set.\n        // This my solve the issue: https://github.com/ionic-team/capacitor/pull/3523\n        PushNotifications.removeDeliveredNotifications({\n          notifications: toRemove,\n        });\n      });\n    } else if (this._platform === 'web') {\n      // TODO: remove web push notification\n    }\n  }\n\n  private getNotificationPayloadData(\n    pushNotification: PushNotificationSchema\n  ): PayloadData {\n    return this._platform === 'ios'\n      ? pushNotification.data.data\n      : pushNotification.data;\n  }\n\n  private async registerCapacitorEvents() {\n    await PushNotifications.addListener('pushNotificationReceived', (n) => {\n      const data = this.getNotificationPayloadData(n);\n      console.log(\n        'Nucleus.Notifications: Received capacitor push event: ' +\n          data.eventType,\n        n\n      );\n      this.handleNotificationEvent(data.notificationId, data.eventType);\n    });\n\n    await PushNotifications.addListener(\n      'pushNotificationActionPerformed',\n      (a) => {\n        let action = (a as any).notification.data.notificationAction;\n        if (this._platform === 'ios') {\n          action = (a as any).notification.data.data.notificationAction;\n        }\n        console.log(\n          'Nucleus.Notifications: Received capacitor action event',\n          action\n        );\n        this.handleNotificationAction(action);\n      }\n    );\n  }\n\n  private registerWebPushEvents() {\n    this.swPush.messages.subscribe((n) => {\n      const data: PayloadData = (n as any).data;\n      console.log(\n        'Nucleus.Notifications: Received WebPush event: ' + data.eventType,\n        n\n      );\n      this.handleNotificationEvent(data.notificationId, data.eventType);\n    });\n\n    this.swPush.notificationClicks.subscribe((action) => {\n      console.log(\n        'Nucleus.Notifications: Received WebPush action event',\n        action\n      );\n      const tag = action.notification.tag;\n      this.handleNotificationAction(tag);\n    });\n  }\n\n  private getRegistrationInfo(): Promise<Registration> {\n    return new Promise((_resolve, _reject) => {\n      const registrationId = window.localStorage.getItem(\n        this.registrationStorageKey\n      ) as string;\n      if (this._platform === 'android' || this._platform === 'ios') {\n        // capacitor platform\n        const listener = PushNotifications.addListener(\n          'registration',\n          (token) => {\n            listener.remove();\n            _resolve({\n              id: registrationId,\n              token: token.value,\n              platform: this._platform,\n            });\n          }\n        );\n        PushNotifications.register().catch((error) =>\n          _reject('Could not register for notifications:' + error)\n        );\n      } else if (this._platform === 'web') {\n        // Web Push API\n        this.http.get<WebKey>(this.apiUrl + 'registration/webkey').subscribe(\n          (key) => {\n            this.getWebPushSubscription(key.publicKey).then((subscription) => {\n              const t = JSON.stringify(subscription.toJSON());\n              _resolve({ id: registrationId, token: t, platform: 'web' });\n            });\n          },\n          (error) => _reject(error)\n        );\n      } else {\n        _reject(`Nucleus.Notifications: Platform is not supported`);\n      }\n    });\n  }\n\n  private getWebPushSubscription(publicKey: string): Promise<PushSubscription> {\n    return new Promise((_resolve, _reject) => {\n      this.swPush.subscription.subscribe(\n        (subscription) => {\n          if (subscription != null) {\n            _resolve(subscription);\n          } else {\n            this.swPush\n              .requestSubscription({ serverPublicKey: publicKey })\n              .then((s) => _resolve(s))\n              .catch((e) => _reject(e));\n          }\n        },\n        (error) => {\n          console.error(\n            'Nucleus.Notifications: Cannot get web push subscription',\n            error\n          );\n          _reject(error);\n        }\n      );\n    });\n  }\n}\n"]}