@esfaenza/signalr-notifications 15.2.19 → 15.2.20

package/{esm2022 → esm2020}/lib/models/BaseMessageService.mjs

@@ -26,10 +26,10 @@ export class BaseMessageService {
     add(endpoint) {
         this.definitions.push(endpoint);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: BaseMessageService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: BaseMessageService }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: BaseMessageService, decorators: [{
+BaseMessageService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: BaseMessageService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+BaseMessageService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: BaseMessageService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: BaseMessageService, decorators: [{
             type: Injectable
         }], ctorParameters: function () { return []; } });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQmFzZU1lc3NhZ2VTZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvc2lnbmFsci1ub3RpZmljYXRpb25zL3NyYy9saWIvbW9kZWxzL0Jhc2VNZXNzYWdlU2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxVQUFVO0FBQ1YsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUUzQyxVQUFVO0FBQ1YsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUM1QyxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sa0JBQWtCLENBQUM7O0FBRWxEOztHQUVHO0FBRUgsTUFBTSxPQUFPLGtCQUFrQjtJQVkzQixvSUFBb0k7SUFDcEksSUFBVyxjQUFjLEtBQThCLE9BQU8sSUFBSSxDQUFDLFdBQVcsQ0FBQyxDQUFDLENBQUM7SUFFakY7UUFiUSxnQkFBVyxHQUE0QixFQUFFLENBQUM7UUFFM0MsK0JBQTBCLEdBQUcsV0FBVyxDQUFDLEVBQUUsQ0FBQywwQkFBMEIsRUFBRSxJQUFJLGNBQWMsRUFBRSxDQUFDLENBQUM7UUFDOUYsbUJBQWMsR0FBRyxXQUFXLENBQUMsRUFBRSxDQUFDLGFBQWEsRUFBRSxFQUFFLENBQUMsQ0FBQztRQUNuRCxrQkFBYSxHQUFHLFdBQVcsQ0FBQyxFQUFFLENBQUMsWUFBWSxFQUFFLEVBQUUsQ0FBQyxDQUFDO1FBQ2pELHdCQUFtQixHQUFHLFdBQVcsQ0FBQyxFQUFFLENBQUMsa0JBQWtCLEVBQUUsRUFBRSxDQUFDLENBQUM7UUFHN0QsdUJBQWtCLEdBQUcsV0FBVyxDQUFDLEdBQUcsQ0FBQyxnQkFBZ0IsRUFBRSxJQUFJLENBQUMsQ0FBQztRQU1oRSxJQUFJLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQywwQkFBMEIsQ0FBQyxDQUFDO1FBQzFDLElBQUksQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLGNBQWMsQ0FBQyxDQUFDO1FBQzlCLElBQUksQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLGFBQWEsQ0FBQyxDQUFDO1FBQzdCLElBQUksQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLG1CQUFtQixDQUFDLENBQUM7UUFDbkMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsa0JBQWtCLENBQUMsQ0FBQztJQUN0QyxDQUFDO0lBRU0sR0FBRyxDQUFDLFFBQStCO1FBQ3RDLElBQUksQ0FBQyxXQUFXLENBQUMsSUFBSSxDQUFDLFFBQVEsQ0FBQyxDQUFDO0lBQ3BDLENBQUM7K0dBekJRLGtCQUFrQjttSEFBbEIsa0JBQWtCOzs0RkFBbEIsa0JBQWtCO2tCQUQ5QixVQUFVIiwic291cmNlc0NvbnRlbnQiOlsiLy8gQW5ndWxhclxyXG5pbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XHJcblxyXG4vLyBNb2RlbGxpXHJcbmltcG9ydCB7IEVuZHBvaW50RGVmIH0gZnJvbSAnLi9FbmRwb2ludERlZic7XHJcbmltcG9ydCB7IEpvYlByb2dyZXNzRHRvIH0gZnJvbSAnLi9Kb2JQcm9ncmVzc0R0byc7XHJcblxyXG4vKipcclxuICogQ2xhc3NlIGJhc2UgZGEgZXN0ZW5kZXJlIGNvbiBsYSBkZWZpbml6aW9uZSBkZWdsaSBFbmRwb2ludCBzdXBwb3J0YXRpIGRhbGwnYXBwbGljYXppb25lXHJcbiAqL1xyXG5ASW5qZWN0YWJsZSgpXHJcbmV4cG9ydCBjbGFzcyBCYXNlTWVzc2FnZVNlcnZpY2Uge1xyXG5cclxuICAgIHByaXZhdGUgZGVmaW5pdGlvbnM6IEVuZHBvaW50RGVmPGFueSwgYW55PltdID0gW107XHJcblxyXG4gICAgcHVibGljIElOX0pvYlByb2dyZXNzTm90aWZpY2F0aW9uID0gRW5kcG9pbnREZWYuSW4oXCJTZW5kUHJvZ3Jlc3NOb3RpZmljYXRpb25cIiwgbmV3IEpvYlByb2dyZXNzRHRvKCkpO1xyXG4gICAgcHVibGljIElOX1NlbmRWZXJzaW9uID0gRW5kcG9pbnREZWYuSW4oXCJTZW5kVmVyc2lvblwiLCBcIlwiKTtcclxuICAgIHB1YmxpYyBJTl9DbGVhckNhY2hlID0gRW5kcG9pbnREZWYuSW4oXCJDbGVhckNhY2hlXCIsIFwiXCIpO1xyXG4gICAgcHVibGljIElOX0NsZWFyUHJlZmVyZWNuZXMgPSBFbmRwb2ludERlZi5JbihcIkNsZWFyUHJlZmVyZWNuZXNcIiwgXCJcIik7XHJcblxyXG5cclxuICAgIHB1YmxpYyBPVVRfUXVlcnlKb2JTdGF0dXMgPSBFbmRwb2ludERlZi5PdXQoXCJRdWVyeUpvYlN0YXR1c1wiLCBudWxsKTtcclxuXHJcbiAgICAvKiogRW50cnlwb2ludCBjaGUgcmVzdGl0dWlzY2UgdHV0dGkgZ2xpIEVuZHBvaW50IGRlbGwnYXBwbGljYXppb25lLiBEYSBvdmVycmlkYXJlIHF1YWxvcmEgbm9uIHZlbmdhIHV0aWxpenphdG8gaWwgbWV0b2RvICoqYWRkKiogKi9cclxuICAgIHB1YmxpYyBnZXQgQWxsRGVmaW5pdGlvbnMoKTogRW5kcG9pbnREZWY8YW55LCBhbnk+W10geyByZXR1cm4gdGhpcy5kZWZpbml0aW9uczsgfVxyXG5cclxuICAgIGNvbnN0cnVjdG9yKCkge1xyXG4gICAgICAgIHRoaXMuYWRkKHRoaXMuSU5fSm9iUHJvZ3Jlc3NOb3RpZmljYXRpb24pO1xyXG4gICAgICAgIHRoaXMuYWRkKHRoaXMuSU5fU2VuZFZlcnNpb24pO1xyXG4gICAgICAgIHRoaXMuYWRkKHRoaXMuSU5fQ2xlYXJDYWNoZSk7XHJcbiAgICAgICAgdGhpcy5hZGQodGhpcy5JTl9DbGVhclByZWZlcmVjbmVzKTtcclxuICAgICAgICB0aGlzLmFkZCh0aGlzLk9VVF9RdWVyeUpvYlN0YXR1cyk7XHJcbiAgICB9XHJcblxyXG4gICAgcHVibGljIGFkZChlbmRwb2ludDogRW5kcG9pbnREZWY8YW55LCBhbnk+KSB7XHJcbiAgICAgICAgdGhpcy5kZWZpbml0aW9ucy5wdXNoKGVuZHBvaW50KTtcclxuICAgIH1cclxufSJdfQ==
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2022 → esm2020}/lib/signalr-notifications.module.mjs

@@ -19,11 +19,11 @@ export class SignalrNotificationsModule {
             ]
         };
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SignalrNotificationsModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
-    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.2.12", ngImport: i0, type: SignalrNotificationsModule }); }
-    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SignalrNotificationsModule }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SignalrNotificationsModule, decorators: [{
+SignalrNotificationsModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: SignalrNotificationsModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+SignalrNotificationsModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.10", ngImport: i0, type: SignalrNotificationsModule });
+SignalrNotificationsModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: SignalrNotificationsModule });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: SignalrNotificationsModule, decorators: [{
             type: NgModule
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/signalr-notifications.service.mjs

@@ -0,0 +1,248 @@
+// Angular
+import { Injectable, Inject } from "@angular/core";
+// Direttive, Componenti, Librerie
+import * as signalR from '@microsoft/signalr';
+import { HubConnectionState } from "@microsoft/signalr";
+import { Subject, EMPTY, from, of } from "rxjs";
+import { catchError, concatMap, delay, tap } from "rxjs/operators";
+import { SGR_DEBUG_MODE, ENDPOINT_URL, MESSAGE_PACK, SIGNALR_ENABLED, AUTO_RECONNECT, AVOID_WS } from "./tokens";
+import * as i0 from "@angular/core";
+import * as i1 from "./models/BaseMessageService";
+/** Servizio che gestisce la comunicazione con un Hub SignalR in base alle configurazioni fornite dall'applicazione */
+export class NotificationsService {
+    /** @ignore Costruttore */
+    constructor(MessageDef, endpoint_url, msgpack, avoidWs, enabled, debug, autoreconnect) {
+        this.MessageDef = MessageDef;
+        this.endpoint_url = endpoint_url;
+        this.msgpack = msgpack;
+        this.avoidWs = avoidWs;
+        this.enabled = enabled;
+        this.debug = debug;
+        this.autoreconnect = autoreconnect;
+        /** Cache degli Observable generati in base agli Endpoint disponibili */
+        this.notifications$ = {};
+        /** Coda di chiamate da recuperare quando la connessione viene finalmente aperta */
+        this.RequestsToRecover = [];
+        if (!this.enabled) {
+            this.log(this.loc("SignalR won't be enabled as per configuration"));
+            return;
+        }
+        this.init();
+    }
+    async init() {
+        this.MessageDef.AllDefinitions.forEach(def => { this.notifications$[def.endpoint] = new Subject(); });
+        let pars = { skipNegotiation: this.avoidWs ? false : true, transport: this.avoidWs ? signalR.HttpTransportType.LongPolling : signalR.HttpTransportType.WebSockets, logger: this.debug ? signalR.LogLevel.Trace : signalR.LogLevel.None };
+        var builder = new signalR.HubConnectionBuilder().withUrl("/" + this.endpoint_url, pars);
+        if (this.autoreconnect) {
+            this.log(this.loc("Building SignalR Hub with Automatic Reconnection"));
+            // 100 tentativi di riconnessione, 1 ogni 5 secondi
+            builder = builder.withAutomaticReconnect(new Array(100).fill(5 * 1000));
+        }
+        if (this.msgpack) {
+            this.log(this.loc("Building SignalR Hub with MessagePack protocol"));
+            var mphpModule = await import("@microsoft/signalr-protocol-msgpack");
+            builder = builder.withHubProtocol(new mphpModule.MessagePackHubProtocol());
+        }
+        this.connection = builder.build();
+        this.connect(() => {
+            if (this.RequestsToRecover.length == 0)
+                return;
+            for (let i = 0; i < this.RequestsToRecover.length; i++) {
+                this.log(this.loc("Recovering request to Endpoint") + " " + this.RequestsToRecover[i].item.endpoint);
+                this.send(this.RequestsToRecover[i].item, this.RequestsToRecover[i].dto);
+            }
+            this.RequestsToRecover = [];
+        });
+    }
+    /**
+     * Effettua la connessione all'Hub Signalr e registra tutti gli Endpoint per cui il Backend comunica con il Frontend sulla **connection**
+     */
+    connect(onConnected) {
+        this.connection.start().catch(err => console.log(err)).then(_ => onConnected?.());
+        this.connection.on("ForceDisconnect", () => { this.connection.stop(); });
+        this.MessageDef.AllDefinitions.forEach(d => {
+            //Registro solo le cose di IN, quelle di out sono chiamate che faccio io al BE quindi non servono
+            if (d.inTypeDefault !== null && (d.outTypeDefault === null || d.outTypeDefault === undefined))
+                this.connection.on(d.endpoint, (message) => {
+                    this.log(this.loc("Request received from the server for endpoint") + " '" + d.endpoint + "': " + (message ? this.substringLog(JSON.stringify(message)) : "[No message]"));
+                    this.notifications$[d.endpoint].next(message);
+                });
+            else
+                this.log(this.loc("Refusing to register endpoint") + " " + d.endpoint + " " + this.loc("because it is not declared as IN - ONLY"));
+        });
+    }
+    /**
+     * Effettua verifiche sulla connessione e, in caso non fosse collegata, tenta di riconnetterla
+     *
+     * @returns {Promise<'OK' | 'KO' | 'NO-OP'>} 'OK' Se la connessione è già connessa o è stata riconnessa con successo, 'KO' Se non è stato possibile riconnettere
+     * una connessione disconnessa, 'NO-OP' se la connesisone è in uno stato intermedio che non può essere modificato
+     */
+    ensureConnected() {
+        if (this.connection.state == HubConnectionState.Disconnected) {
+            this.log(this.loc("Connection lost or missing, reconnecting..."));
+            return this.connection.start()
+                .then(_ => {
+                return Promise.resolve("OK");
+            }, _ => {
+                this.log(this.loc("Cannot reconnect SignalR, frontend HUB offline"));
+                return Promise.resolve("KO");
+            });
+        }
+        else if (this.connection.state == HubConnectionState.Connected)
+            return Promise.resolve("OK");
+        else
+            return Promise.resolve("NO-OP");
+    }
+    /**
+     * Invia un messaggio all'Hub del Backend
+     *
+     * @param {EndpointDef<any, TOut>} item Endpoint da contattare
+     * @param {TOut} dto Dto da inviare all'Endpoint
+     */
+    send(item, dto) {
+        if (!this.connection) {
+            this.RequestsToRecover.push({ item, dto });
+            return;
+        }
+        if (!this.enabled) {
+            this.log(this.loc("Send request ignored because SignalR is not active by configuration"));
+            return EMPTY;
+        }
+        if (this.connection.state == HubConnectionState.Connecting || this.connection.state == HubConnectionState.Reconnecting || this.connection.state == HubConnectionState.Disconnecting) {
+            this.log(this.loc("Send request sent before a connection was in stable State, waiting 1 second and retrying"));
+            setTimeout(() => { this.send(item, dto); }, 1000);
+        }
+        else if (this.connection.state == HubConnectionState.Disconnected) {
+            this.ensureConnected().then(t => {
+                if (t == "KO")
+                    this.log(this.loc("ERRORS on reconnecting before retrying a send command. Sent message WILL BE LOST"));
+                else
+                    this.send(item, dto);
+            });
+        }
+        else {
+            this.connection.send(item.endpoint, dto).then(_ => {
+                if (this.debug)
+                    console.info(this.loc("Request sent to server") + " - " + item.endpoint + ": " + this.substringLog(JSON.stringify(dto)));
+            });
+        }
+    }
+    /**
+     * Invia un messaggio all'Hub del Backend, aspettandosi una risposta
+     *
+     * @param {EndpointDef<TOut, TIn>} item Endpoint da contattare
+     * @param {TOut} dto Dto da inviare all'Endpoint
+     *
+     * @returns {Observable<TIn>} Observable su cui ci si può registrare per ricevere il risultato della chiamata
+     */
+    invoke(item, dto) {
+        if (!this.enabled) {
+            this.log(this.loc("Invoke request ignored because SignalR is not active by configuration"));
+            return EMPTY;
+        }
+        if (this.connection.state == HubConnectionState.Connecting || this.connection.state == HubConnectionState.Reconnecting || this.connection.state == HubConnectionState.Disconnecting) {
+            this.log(this.loc("Invoke request sent before a connection was in stable State, waiting 1 second and retrying"));
+            return of().pipe(delay(1000), concatMap(() => this.invoke(item, dto)));
+        }
+        else if (this.connection.state == HubConnectionState.Disconnected) {
+            return from(this.ensureConnected()).pipe(concatMap((res) => {
+                if (res == "KO") {
+                    this.log(this.loc("ERRORS on reconnecting before retrying a send command. Sent message WILL BE LOST"));
+                    return EMPTY;
+                }
+                else
+                    return this.invoke(item, dto);
+            }));
+        }
+        else {
+            return from(this.connection.invoke(item.endpoint, dto)).pipe(tap(() => {
+                if (this.debug)
+                    console.log(this.loc("Request invoked to server") + " - " + item.endpoint + ": " + this.substringLog(JSON.stringify(dto)));
+            }));
+        }
+    }
+    /**
+     * Hook per osservare i dati spediti ad un Endpoint dal Backend
+     *
+     * @param {EndpointDef<TIn, any>} item Endpoint su cui ascoltare
+     *
+     * @returns {Observable<TIn>} Observable su cui ci si può registrare per ricevere l'oggetto generato ad ogni chiamata dal Backend al Frontend
+     */
+    observe(item) {
+        if (!this.enabled) {
+            this.log(this.loc("Observe request ignored because SignalR is not active by configuration"));
+            return EMPTY;
+        }
+        this.log(this.loc("Returning observable for required endpoint") + ": " + item.endpoint);
+        return this.notifications$[item.endpoint];
+    }
+    /**
+     * Disconnessione del sistema di SignalR
+     *
+     * @returns {Observable<void>} Observable a cui registrarsi che viene chiamato quando la disconnessione è terminata
+     */
+    disconnect() {
+        //NO-OP se non attivo
+        if (!this.enabled) {
+            this.log(this.loc("Disconnection request ignored because SignalR is not active by configuration"));
+            return EMPTY;
+        }
+        return from(this.connection.stop()).pipe(catchError((err, caught) => { console.log(err); return of(null); }), tap(() => {
+            this.log(this.loc("Disconnection request honored"));
+        }));
+    }
+    /**
+     * Taglia un log troppo lungo
+     *
+     * @param {string} text Log da tagliare
+     * @param {number} maxchars Numero massimo di caratteri da tenere
+     *
+     * @returns {string} Log tagliato
+     */
+    substringLog(text, maxchars = 120) {
+        return text.length > maxchars ? text.substr(0, maxchars) + "[...]" : text;
+    }
+    /**
+     * Stampa un log a console
+     *
+     * @param {string} message Messaggio da stampare
+     */
+    log(message) {
+        if (this.debug)
+            console.log("@signalr-notifications: " + message);
+    }
+    /**
+     * Helper di localizzazione
+     *
+     * @param {string} message Messaggio da tradurre
+     *
+     * @returns {string} Messaggio tradotto
+     */
+    loc(message) {
+        return message;
+    }
+}
+NotificationsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: NotificationsService, deps: [{ token: i1.BaseMessageService }, { token: ENDPOINT_URL }, { token: MESSAGE_PACK }, { token: AVOID_WS }, { token: SIGNALR_ENABLED }, { token: SGR_DEBUG_MODE }, { token: AUTO_RECONNECT }], target: i0.ɵɵFactoryTarget.Injectable });
+NotificationsService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: NotificationsService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: NotificationsService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.BaseMessageService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [ENDPOINT_URL]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [MESSAGE_PACK]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [AVOID_WS]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [SIGNALR_ENABLED]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [SGR_DEBUG_MODE]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [AUTO_RECONNECT]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"signalr-notifications.service.js","sourceRoot":"","sources":["../../../../projects/signalr-notifications/src/lib/signalr-notifications.service.ts"],"names":[],"mappings":"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","sourcesContent":["// Angular\r\nimport { Injectable, Inject } from \"@angular/core\";\r\n\r\n// Direttive, Componenti, Librerie\r\nimport * as signalR from '@microsoft/signalr';\r\nimport { HubConnectionState } from \"@microsoft/signalr\";\r\nimport { Observable, Subject, EMPTY, from, of } from \"rxjs\";\r\nimport { catchError, concatMap, delay, tap } from \"rxjs/operators\";\r\n\r\n// Modelli\r\nimport { BaseMessageService } from './models/BaseMessageService';\r\nimport { EndpointDef } from './models/EndpointDef';\r\nimport { SGR_DEBUG_MODE, ENDPOINT_URL, MESSAGE_PACK, SIGNALR_ENABLED, AUTO_RECONNECT, AVOID_WS } from \"./tokens\";\r\n\r\n/** Servizio che gestisce la comunicazione con un Hub SignalR in base alle configurazioni fornite dall'applicazione */\r\n@Injectable()\r\nexport class NotificationsService {\r\n\r\n    /** Cache degli Observable generati in base agli Endpoint disponibili */\r\n    private notifications$: { [index: string]: Subject<any> } = {};\r\n\r\n    /** Connessione Signalr */\r\n    private connection: signalR.HubConnection;\r\n\r\n     /** Coda di chiamate da recuperare quando la connessione viene finalmente aperta */\r\n     private RequestsToRecover: { item: EndpointDef<any, any>, dto: any }[] = [];\r\n\r\n     /** @ignore Costruttore */\r\n    constructor(private MessageDef: BaseMessageService, @Inject(ENDPOINT_URL) private endpoint_url: string, @Inject(MESSAGE_PACK) private msgpack: boolean,  @Inject(AVOID_WS) private avoidWs: boolean, @Inject(SIGNALR_ENABLED) private enabled: boolean, @Inject(SGR_DEBUG_MODE) private debug: boolean, @Inject(AUTO_RECONNECT) private autoreconnect: boolean) {\r\n        if (!this.enabled) {\r\n            this.log(this.loc(\"SignalR won't be enabled as per configuration\"));\r\n            return;\r\n        }\r\n\r\n        this.init();\r\n    }\r\n\r\n    private async init(){\r\n        this.MessageDef.AllDefinitions.forEach(def => { this.notifications$[def.endpoint] = new Subject<typeof def.inTypeDefault>(); });\r\n\r\n        let pars: signalR.IHttpConnectionOptions = { skipNegotiation: this.avoidWs ? false : true, transport: this.avoidWs ? signalR.HttpTransportType.LongPolling : signalR.HttpTransportType.WebSockets, logger: this.debug ? signalR.LogLevel.Trace : signalR.LogLevel.None };\r\n        var builder = new signalR.HubConnectionBuilder().withUrl(\"/\" + this.endpoint_url, pars);\r\n\r\n        if (this.autoreconnect) {\r\n            this.log(this.loc(\"Building SignalR Hub with Automatic Reconnection\"));\r\n            // 100 tentativi di riconnessione, 1 ogni 5 secondi\r\n            builder = builder.withAutomaticReconnect(new Array(100).fill(5 * 1000));\r\n        }\r\n\r\n        if (this.msgpack) {\r\n            this.log(this.loc(\"Building SignalR Hub with MessagePack protocol\"));\r\n            var mphpModule = await import(\"@microsoft/signalr-protocol-msgpack\");\r\n            builder = builder.withHubProtocol(new mphpModule.MessagePackHubProtocol())\r\n        }\r\n\r\n        this.connection = builder.build();\r\n        this.connect(() => {\r\n            if (this.RequestsToRecover.length == 0)\r\n                return;\r\n\r\n            for (let i = 0; i < this.RequestsToRecover.length; i++) {\r\n                this.log(this.loc(\"Recovering request to Endpoint\") + \" \" + this.RequestsToRecover[i].item.endpoint)\r\n                this.send(this.RequestsToRecover[i].item, this.RequestsToRecover[i].dto);\r\n            }\r\n\r\n            this.RequestsToRecover = [];\r\n        });\r\n    }\r\n\r\n    /**\r\n     * Effettua la connessione all'Hub Signalr e registra tutti gli Endpoint per cui il Backend comunica con il Frontend sulla **connection**\r\n     */\r\n    private connect(onConnected?: () => void) {\r\n        this.connection.start().catch(err => console.log(err)).then(_ => onConnected?.());\r\n        this.connection.on(\"ForceDisconnect\", () => { this.connection.stop(); });\r\n        this.MessageDef.AllDefinitions.forEach(d => {\r\n            //Registro solo le cose di IN, quelle di out sono chiamate che faccio io al BE quindi non servono\r\n            if (d.inTypeDefault !== null && (d.outTypeDefault === null || d.outTypeDefault === undefined))\r\n                this.connection.on(d.endpoint, (message) => {\r\n                    this.log(this.loc(\"Request received from the server for endpoint\") + \" '\" + d.endpoint + \"': \" + (message ? this.substringLog(JSON.stringify(message)): \"[No message]\"));\r\n                    this.notifications$[d.endpoint].next(message);\r\n                });\r\n            else\r\n                this.log(this.loc(\"Refusing to register endpoint\") + \" \" + d.endpoint + \" \" + this.loc(\"because it is not declared as IN - ONLY\"));\r\n        });\r\n    }\r\n\r\n    /**\r\n     * Effettua verifiche sulla connessione e, in caso non fosse collegata, tenta di riconnetterla\r\n     * \r\n     * @returns {Promise<'OK' | 'KO' | 'NO-OP'>} 'OK' Se la connessione è già connessa o è stata riconnessa con successo, 'KO' Se non è stato possibile riconnettere \r\n     * una connessione disconnessa, 'NO-OP' se la connesisone è in uno stato intermedio che non può essere modificato\r\n     */\r\n    public ensureConnected(): Promise<'OK' | 'KO' | 'NO-OP'> {\r\n        if (this.connection.state == HubConnectionState.Disconnected) {\r\n            this.log(this.loc(\"Connection lost or missing, reconnecting...\"));\r\n\r\n            return this.connection.start()\r\n                .then(_ => {\r\n                    return Promise.resolve(\"OK\");\r\n                }, _ => {\r\n                    this.log(this.loc(\"Cannot reconnect SignalR, frontend HUB offline\"));\r\n                    return Promise.resolve(\"KO\");\r\n                });\r\n        }\r\n        else if (this.connection.state == HubConnectionState.Connected)\r\n            return Promise.resolve(\"OK\");\r\n        else\r\n            return Promise.resolve(\"NO-OP\");\r\n    }\r\n\r\n\r\n    /**\r\n     * Invia un messaggio all'Hub del Backend\r\n     * \r\n     * @param {EndpointDef<any, TOut>} item Endpoint da contattare\r\n     * @param {TOut} dto Dto da inviare all'Endpoint\r\n     */\r\n    public send<TOut>(item: EndpointDef<any, TOut>, dto: TOut) {\r\n        if (!this.connection) {\r\n            this.RequestsToRecover.push({ item, dto });\r\n            return;\r\n        }\r\n\r\n        if (!this.enabled) {\r\n            this.log(this.loc(\"Send request ignored because SignalR is not active by configuration\"));\r\n            return EMPTY;\r\n        }\r\n\r\n        if (this.connection.state == HubConnectionState.Connecting || this.connection.state == HubConnectionState.Reconnecting || this.connection.state == HubConnectionState.Disconnecting) {\r\n            this.log(this.loc(\"Send request sent before a connection was in stable State, waiting 1 second and retrying\"));\r\n            setTimeout(() => { this.send(item, dto); }, 1000);\r\n        }\r\n        else if (this.connection.state == HubConnectionState.Disconnected) {\r\n            this.ensureConnected().then(t => {\r\n                if (t == \"KO\") this.log(this.loc(\"ERRORS on reconnecting before retrying a send command. Sent message WILL BE LOST\"));\r\n                else this.send(item, dto);\r\n            })\r\n        }\r\n        else {\r\n            this.connection.send(item.endpoint, dto).then(_ => {\r\n                if (this.debug)\r\n                    console.info(this.loc(\"Request sent to server\") + \" - \" + item.endpoint + \": \" + this.substringLog(JSON.stringify(dto)));\r\n            });\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Invia un messaggio all'Hub del Backend, aspettandosi una risposta\r\n     * \r\n     * @param {EndpointDef<TOut, TIn>} item Endpoint da contattare\r\n     * @param {TOut} dto Dto da inviare all'Endpoint\r\n     * \r\n     * @returns {Observable<TIn>} Observable su cui ci si può registrare per ricevere il risultato della chiamata\r\n     */\r\n    public invoke<TOut, TIn>(item: EndpointDef<TOut, TIn>, dto: TOut): Observable<TIn> {\r\n        if (!this.enabled) {\r\n            this.log(this.loc(\"Invoke request ignored because SignalR is not active by configuration\"));\r\n            return EMPTY;\r\n        }\r\n\r\n        if (this.connection.state == HubConnectionState.Connecting || this.connection.state == HubConnectionState.Reconnecting || this.connection.state == HubConnectionState.Disconnecting) {\r\n            this.log(this.loc(\"Invoke request sent before a connection was in stable State, waiting 1 second and retrying\"));\r\n            return of().pipe(delay(1000), concatMap(() => this.invoke(item, dto)));\r\n        }\r\n        else if (this.connection.state == HubConnectionState.Disconnected) {\r\n            return from(this.ensureConnected()).pipe(concatMap((res) => {\r\n                if (res == \"KO\") {\r\n                    this.log(this.loc(\"ERRORS on reconnecting before retrying a send command. Sent message WILL BE LOST\"));\r\n                    return EMPTY;\r\n                }\r\n                else return this.invoke(item, dto);\r\n            }))\r\n        }\r\n        else {\r\n            return from(this.connection.invoke<TIn>(item.endpoint, dto)).pipe(\r\n                tap(() => {\r\n                    if (this.debug) console.log(this.loc(\"Request invoked to server\") + \" - \" + item.endpoint + \": \" + this.substringLog(JSON.stringify(dto)));\r\n                })\r\n            );\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Hook per osservare i dati spediti ad un Endpoint dal Backend\r\n     * \r\n     * @param {EndpointDef<TIn, any>} item Endpoint su cui ascoltare\r\n     * \r\n     * @returns {Observable<TIn>} Observable su cui ci si può registrare per ricevere l'oggetto generato ad ogni chiamata dal Backend al Frontend\r\n     */\r\n    public observe<TIn>(item: EndpointDef<TIn, any>): Observable<TIn> {\r\n        if (!this.enabled) {\r\n            this.log(this.loc(\"Observe request ignored because SignalR is not active by configuration\"));\r\n            return EMPTY;\r\n        }\r\n\r\n        this.log(this.loc(\"Returning observable for required endpoint\") + \": \" + item.endpoint);\r\n        return <Observable<TIn>>this.notifications$[item.endpoint];\r\n    }\r\n\r\n    /**\r\n     * Disconnessione del sistema di SignalR\r\n     * \r\n     * @returns {Observable<void>} Observable a cui registrarsi che viene chiamato quando la disconnessione è terminata\r\n     */\r\n    public disconnect(): Observable<void> {\r\n        //NO-OP se non attivo\r\n        if (!this.enabled) {\r\n            this.log(this.loc(\"Disconnection request ignored because SignalR is not active by configuration\"));\r\n            return EMPTY;\r\n        }\r\n\r\n        return from(this.connection.stop()).pipe(\r\n            catchError((err, caught) => { console.log(err); return of(null); }),\r\n            tap(() => {\r\n                this.log(this.loc(\"Disconnection request honored\"));\r\n            })\r\n        );\r\n    }\r\n\r\n    /**\r\n     * Taglia un log troppo lungo\r\n     * \r\n     * @param {string} text Log da tagliare\r\n     * @param {number} maxchars Numero massimo di caratteri da tenere\r\n     * \r\n     * @returns {string} Log tagliato\r\n     */\r\n    private substringLog(text: string, maxchars: number = 120): string {\r\n        return text.length > maxchars ? text.substr(0, maxchars) + \"[...]\" : text;\r\n    }\r\n\r\n    /**\r\n     * Stampa un log a console\r\n     * \r\n     * @param {string} message Messaggio da stampare\r\n     */\r\n    private log(message: string) {\r\n        if (this.debug)\r\n            console.log(\"@signalr-notifications: \" + message)\r\n    }\r\n\r\n    /**\r\n     * Helper di localizzazione\r\n     * \r\n     * @param {string} message Messaggio da tradurre\r\n     * \r\n     * @returns {string} Messaggio tradotto\r\n     */\r\n    private loc(message: string) : string{\r\n        return message;\r\n    }\r\n}"]}