@esfaenza/extensions 15.2.46 → 16.0.2

package/esm2022/lib/services/extensions.messages.service.mjs

@@ -0,0 +1,450 @@
+// Angular
+import { Injectable, Inject, Optional, Injector } from "@angular/core";
+// Configurazioni
+import { ToastrService } from "ngx-toastr";
+import swal from "sweetalert2";
+// RXJS
+import { of } from "rxjs";
+import { filter, first, map, take } from "rxjs/operators";
+import * as i0 from "@angular/core";
+import * as i1 from "@esfaenza/localizations";
+import * as i2 from "./extensions.hashing.service";
+/**
+ * Service che fornisce funzionalità di alert nei tipi fondamentali: success, info, warning e danger
+ */
+export class MessageService {
+    injector;
+    locProvider;
+    hash;
+    /** Oggetto statico in supporto alla localizzazione */
+    loc = {
+        'Confirm': { 'en-US': "Confirm", 'it-IT': "Conferma", },
+        'Cancel': { 'en-US': "Cancel", 'it-IT': "Annulla", },
+        'Close': { 'en-US': "Close", 'it-IT': "Chiudi", },
+        'Error': { 'en-US': "Error", 'it-IT': "Errore", },
+        'Info': { 'en-US': "Info", 'it-IT': "Informazione", },
+        'Success': { 'en-US': "Success", 'it-IT': "Successo", },
+        'Warning': { 'en-US': "Warning", 'it-IT': "Attenzione", }
+    };
+    /** Template di un warning con richiesta di conferma */
+    warningSwalWithCancel;
+    /** Template di un warning con richiesta di conferma */
+    successSwalWithCancel;
+    /** Template di un errore */
+    errorSwal;
+    /** Template di un messaggio di successo */
+    successSwal;
+    /** Template di un avviso */
+    warningSwal;
+    /** Template di un messaggio informativo */
+    infoSwal;
+    /** Template di un warning per la sessione scaduta */
+    expiredSessionSwal;
+    /** Getter per il servizio dei toast. ngx-toastr è fatta talmente male che la service dev'essere recuperata in questo modo */
+    get toastr() {
+        return this.injector.get(ToastrService);
+    }
+    /** Supporto all'Embedding */
+    Embedded = false;
+    MainWindow = null;
+    MessageObserver = null;
+    /** Costruttore  @ignore */
+    constructor(injector, locProvider, hash) {
+        this.injector = injector;
+        this.locProvider = locProvider;
+        this.hash = hash;
+        this.init();
+    }
+    configureEmbeddability(mainWindow, messageObserver) {
+        this.Embedded = true;
+        this.MainWindow = mainWindow;
+        this.MessageObserver = messageObserver;
+    }
+    async init() {
+        let LOCALE = this.locProvider ? await this.locProvider.Locale.pipe(first()).toPromise() : 'it-IT';
+        this.expiredSessionSwal = swal.mixin({
+            showCancelButton: false,
+            confirmButtonText: 'Login',
+            customClass: {
+                confirmButton: "btn btn-primary",
+                container: "app-wrap",
+            },
+            buttonsStyling: false,
+            reverseButtons: false,
+            allowOutsideClick: false,
+            icon: "warning"
+        });
+        this.successSwalWithCancel = swal.mixin({
+            title: this.loc["Success"][LOCALE],
+            customClass: {
+                confirmButton: "btn btn-primary",
+                cancelButton: "btn btn-secondary app-margin-right-10",
+                container: "app-wrap",
+            },
+            buttonsStyling: false,
+            reverseButtons: true,
+            showCancelButton: true,
+            confirmButtonText: this.loc["Confirm"][LOCALE],
+            cancelButtonText: this.loc["Cancel"][LOCALE],
+            icon: "success"
+        });
+        this.warningSwalWithCancel = swal.mixin({
+            title: this.loc["Warning"][LOCALE],
+            customClass: {
+                confirmButton: "btn btn-primary",
+                cancelButton: "btn btn-secondary app-margin-right-10",
+                container: "app-wrap",
+            },
+            buttonsStyling: false,
+            reverseButtons: true,
+            showCancelButton: true,
+            confirmButtonText: this.loc["Confirm"][LOCALE],
+            cancelButtonText: this.loc["Cancel"][LOCALE],
+            icon: "warning"
+        });
+        this.warningSwal = swal.mixin({
+            title: this.loc["Warning"][LOCALE],
+            customClass: {
+                confirmButton: "btn btn-primary",
+                container: "app-wrap",
+            },
+            buttonsStyling: false,
+            reverseButtons: true,
+            showCancelButton: false,
+            confirmButtonText: this.loc["Close"][LOCALE],
+            icon: "warning"
+        });
+        this.successSwal = swal.mixin({
+            title: this.loc["Success"][LOCALE],
+            customClass: {
+                confirmButton: "btn btn-primary",
+                container: "app-wrap",
+            },
+            buttonsStyling: false,
+            reverseButtons: true,
+            showCancelButton: false,
+            confirmButtonText: this.loc["Close"][LOCALE],
+            icon: "success"
+        });
+        this.errorSwal = swal.mixin({
+            title: this.loc["Error"][LOCALE],
+            customClass: {
+                confirmButton: "btn btn-primary",
+                container: "app-wrap",
+            },
+            buttonsStyling: false,
+            reverseButtons: true,
+            showCancelButton: false,
+            confirmButtonText: this.loc["Close"][LOCALE],
+            icon: "error"
+        });
+        this.infoSwal = swal.mixin({
+            title: this.loc["Info"][LOCALE],
+            customClass: {
+                confirmButton: "btn btn-primary",
+                container: "app-wrap",
+            },
+            buttonsStyling: false,
+            reverseButtons: true,
+            showCancelButton: false,
+            confirmButtonText: this.loc["Close"][LOCALE],
+            icon: "info"
+        });
+    }
+    /**
+     * Presentazione di un semplice messaggio di successo
+     *
+     * Se viene chiamato con le impostazioni di default e toastr è abilitato, viene mostrato al centro
+     * Se viene chiamato con override su toastr vuol dire che è una notifica secondaria e appare in alto a destra
+     *
+     * @param {string} text Testo da mostrare
+     * @param {"toastr" | "swal" | null} secondaryNotificationType Qualora sia una notifica secondaria, ne indica il tipo
+     */
+    simpleSuccess(text, secondaryNotificationType = null, secondaryNotificationTimeout = null) {
+        if (this.Embedded) {
+            this.MainWindow.postMessage({ type: "alert", level: 'success', msg: text }, "*");
+            return;
+        }
+        let tos = this.toastrOrSwal(secondaryNotificationType);
+        if (tos == "swal")
+            this.successSwal.fire("", text);
+        else
+            this.toastr.success(text, null, { positionClass: tos == "toastr" ? "toast-top-right" : "toast-top-center", timeOut: secondaryNotificationTimeout || (tos == "toastr" ? 0 : 5000), extendedTimeOut: tos == "toastr" ? 0 : 1000 });
+    }
+    /**
+     * Presentazione di un semplice messaggio di informazione
+     *
+     * Se viene chiamato con le impostazioni di default e toastr è abilitato, viene mostrato al centro
+     * Se viene chiamato con override su toastr vuol dire che è una notifica secondaria e appare in alto a destra
+     *
+     * @param {string} text Testo da mostrare
+     * @param {"toastr" | "swal" | null} secondaryNotificationType Qualora sia una notifica secondaria, ne indica il tipo
+     */
+    simpleInfo(text, secondaryNotificationType = null, secondaryNotificationTimeout = null) {
+        if (this.Embedded) {
+            this.MainWindow.postMessage({ type: "alert", level: 'info', msg: text }, "*");
+            return;
+        }
+        let tos = this.toastrOrSwal(secondaryNotificationType);
+        if (tos == "swal")
+            this.infoSwal.fire("", text);
+        else
+            this.toastr.info(text, null, { positionClass: tos == "toastr" ? "toast-top-right" : "toast-top-center", timeOut: secondaryNotificationTimeout || (tos == "toastr" ? 0 : 5000), extendedTimeOut: tos == "toastr" ? 0 : 1000 });
+    }
+    /**
+     * Presentazione di un semplice messaggio di errore
+     *
+     * Se viene chiamato con le impostazioni di default e toastr è abilitato, viene mostrato al centro
+     * Se viene chiamato con override su toastr vuol dire che è una notifica secondaria e appare in alto a destra
+     *
+     * @param {string} text Testo da mostrare
+     * @param {"toastr" | "swal" | null} secondaryNotificationType Qualora sia una notifica secondaria, ne indica il tipo
+     */
+    simpleError(text, secondaryNotificationType = null, secondaryNotificationTimeout = null) {
+        if (this.Embedded) {
+            this.MainWindow.postMessage({ type: "alert", level: 'error', msg: text }, "*");
+            return;
+        }
+        let tos = this.toastrOrSwal(secondaryNotificationType);
+        if (tos == "swal")
+            this.errorSwal.fire("", text);
+        else
+            this.toastr.error(text, null, { positionClass: tos == "toastr" ? "toast-top-right" : "toast-top-center", timeOut: secondaryNotificationTimeout || (tos == "toastr" ? 0 : 5000), extendedTimeOut: tos == "toastr" ? 0 : 1000 });
+    }
+    /**
+     * Presentazione di un semplice messaggio di avviso
+     *
+     * Se viene chiamato con le impostazioni di default e toastr è abilitato, viene mostrato al centro
+     * Se viene chiamato con override su toastr vuol dire che è una notifica secondaria e appare in alto a destra
+     *
+     * @param {string} text Testo da mostrare
+     * @param {"toastr" | "swal" | null} secondaryNotificationType Qualora sia una notifica secondaria, ne indica il tipo
+     */
+    simpleWarning(text, secondaryNotificationType = null, secondaryNotificationTimeout = null) {
+        if (this.Embedded) {
+            this.MainWindow.postMessage({ type: "alert", level: 'warning', msg: text }, "*");
+            return;
+        }
+        let tos = this.toastrOrSwal(secondaryNotificationType);
+        if (tos == "swal")
+            this.warningSwal.fire("", text);
+        else
+            this.toastr.warning(text, null, { positionClass: tos == "toastr" ? "toast-top-right" : "toast-top-center", timeOut: secondaryNotificationTimeout || (tos == "toastr" ? 0 : 5000), extendedTimeOut: tos == "toastr" ? 0 : 1000 });
+    }
+    /**
+     * Ripulisce tutti i messaggi presenti in un dato momento sullo schermo
+     */
+    clearMessages() {
+        this.toastr.clear();
+        swal.close();
+    }
+    /**
+     * Mostra un messaggio di avviso con richiesta di conferma
+     *
+     * @param {string} title Titolo del messaggio
+     * @param {string} text Contenuto del messaggio
+     *
+     * @returns {Promise} Restituisce una Promise col risultato scelto dall'utente (conferma o no)
+     */
+    promiseWarningWithChoice(title, text) {
+        return this.warningSwalWithCancel.fire(title, text);
+    }
+    /**
+     * In base alla configurazione attuale e all'eventuale override per la chiamata del caso indica se bisogna utilizzare toastr o sweetalert
+     *
+     * @param {"toastr" | "swal" | null} providerOverride Override alla modalità configurata
+     *
+     * @returns {"toastr" | "swal"} Indicazione su che provider di messaggi di avviso debba essere utilizzato
+     */
+    toastrOrSwal(providerOverride) {
+        if (providerOverride != null)
+            return providerOverride;
+        return "swal";
+    }
+    GuidRepsonseFunctionsMap = {};
+    simpleWarningWithChoice(title, text, onsuccess, onerror, confirmtext = "", aborttext = '') {
+        this.withChoiceBase("warning", title, text, onsuccess, onerror, confirmtext, aborttext);
+    }
+    simpleSuccessWithChoice(title, text, onsuccess, onerror, confirmtext = "", aborttext = '') {
+        this.withChoiceBase("success", title, text, onsuccess, onerror, confirmtext, aborttext);
+    }
+    withChoiceBase(level, title, text, onsuccess, onerror, confirmtext = "", aborttext = '') {
+        if (this.Embedded) {
+            let guid = this.hash.getGUID();
+            this.GuidRepsonseFunctionsMap[guid] = { onsuccess, onerror };
+            this.MainWindow.postMessage({ type: "confirm", level, title, text, guid }, "*");
+            // Observe sulla risposta
+            console.log("Inviata confirm request alla pagina principale, in attesa di risposta...");
+            this.MessageObserver.pipe(filter(event => event?.data?.type == "confirm-response" && event?.data?.guid == guid), take(1)).subscribe(event => {
+                console.log("Event listener su window-message. Risposta pergiunta");
+                if (event?.data?.result === true)
+                    this.GuidRepsonseFunctionsMap[guid].onsuccess();
+                else if (event?.data?.result === true)
+                    this.GuidRepsonseFunctionsMap[guid].onerror();
+            });
+        }
+        else
+            (level == "warning" ? this._simpleWarningWithChoice.bind(this) : this._simpleSuccessWithChoice.bind(this))(title, text, onsuccess, onerror, confirmtext, aborttext);
+    }
+    /**
+     * Mostra un messaggio di avviso con richiesta di conferma e gestisce il risultato chiamato i callback **onsuccess** o **onerror**
+     *
+     * @param {string} title Titolo del messaggio
+     * @param {string} text Contenuto del messaggio
+     * @param {Function} onsuccess Callback da chimare su conferma
+     * @param {Function} onerror Callback da chimare su errori
+     */
+    _simpleWarningWithChoice(title, text, onconfirm = null, onabort = null, confirmtext = "", aborttext = '') {
+        this._simpleWithChoice(this.warningSwalWithCancel, title, text, onconfirm, onabort, confirmtext, aborttext);
+    }
+    /**
+     * Mostra un messaggio di success con richiesta di conferma e gestisce il risultato chiamato i callback **onconfirm** o **onabort**
+     *
+     * @param {string} title Titolo del messaggio
+     * @param {string} text Contenuto del messaggio
+     * @param {Function} onconfirm Callback da chimare su conferma
+     * @param {Function} onabort Callback da chimare su annullamento
+     * @param {string} confirmtext Testo del pulsante di azione
+     * @param {string} aborttext Testo del pulsante di annullamento
+     */
+    _simpleSuccessWithChoice(title, text, onconfirm = null, onabort = null, confirmtext = "", aborttext = '') {
+        this._simpleWithChoice(this.successSwalWithCancel, title, text, onconfirm, onabort, confirmtext, aborttext);
+    }
+    /**
+     * Metodo base per richiedere una scelta all'utente
+     *
+     * @param {any} swal Swal mixin da utilizzare per visualizzare il messaggio di choice
+     * @param {string} title Titolo del messaggio
+     * @param {string} text Contenuto del messaggio
+     * @param {Function} onconfirm Callback da chimare su conferma
+     * @param {Function} onabort Callback da chimare su annullamento
+     * @param {string} confirmtext Testo del pulsante di azione
+     * @param {string} aborttext Testo del pulsante di annullamento
+     */
+    _simpleWithChoice(swal, title, text, onconfirm = null, onabort = null, confirmtext = "", aborttext = '') {
+        var configuration = {
+            title: title,
+            html: text
+        };
+        if (confirmtext)
+            configuration["confirmButtonText"] = confirmtext;
+        if (aborttext)
+            configuration["cancelButtonText"] = aborttext;
+        swal.fire(configuration).then((result) => {
+            if (result.value && onconfirm)
+                onconfirm();
+            else if (onabort)
+                onabort();
+        });
+    }
+    /**
+     * Mostra un messaggio di avviso con richiesta di conferma e gestisce il risultato chiamato i callback **onsuccess** o **onerror**
+     *
+     * @param {string} title Titolo del messaggio
+     * @param {string} text Contenuto del messaggio
+     */
+    observableSimpleWarningWithChoice(title, text) {
+        return of(this.warningSwalWithCancel.fire(title, text)).pipe(map(t => !!t.value));
+    }
+    /**
+     * Mostra un messaggio di avviso che la sessione corrente è scaduta e propone all'utente di navigare al login. Qualora l'utente decidesse di farlo
+     * verrà chiamata la funzione di callback **onnavigate
+     *
+     * @param {string} title Titolo del messaggio
+     * @param {string} text Contenuto del messaggio
+     * @param {Function} onnavigate Callback da chimare su navigazione in corso
+     */
+    expiredSessionMessage(title, text, onnavigate = null) {
+        this.expiredSessionSwal.fire(title, text).then((result) => {
+            if (result.value && onnavigate)
+                onnavigate();
+        });
+    }
+    /**
+     * Metodo helper per gestire in maniera standardizzata una risposta di tipo **CallResult**
+     *
+     * @param {CallResult} response Risposta ricevuta dal server
+     * @param {string} successMsg Messaggio da visualizzare in caso di successo
+     * @param {string} errorMsg Messaggio da visualizzare in caso di fallimento
+     * @param {Function} postSuccess Callback da chimare in caso di successo
+     * @param {Function} postFailure Callback da chimare in caso di fallimento
+     */
+    manageCallResultResponse(response, successMsg, errorMsg, postSuccess = null, postFailure = null) {
+        let anyReponse = response;
+        if (response.success || anyReponse.Success) {
+            if (response.haswarning || anyReponse.HasWarning)
+                this.simpleWarning(response.warning || anyReponse.Warning);
+            else if (successMsg)
+                this.simpleSuccess(successMsg);
+            if (postSuccess)
+                postSuccess();
+        }
+        else {
+            this.simpleError((errorMsg ? errorMsg + ": " : "") + ((response.haserror || anyReponse.HasError) ? (response.error || anyReponse.Error) : '[NO ERR.]'));
+            if (postFailure)
+                postFailure();
+        }
+    }
+    /**
+     * Metodo helper per gestire in maniera standardizzata una risposta di tipo **string**, considerando che:
+     *
+     * Stringa vuota --> Tutto bene
+     *
+     * Stringa piena --> Questo è il messaggio d'errore per cui la chiamata è fallita
+     *
+     * @param {string} response Risposta ricevuta dal server
+     * @param {string} successMsg Messaggio da visualizzare in caso di successo
+     * @param {string} errorMsg Messaggio da visualizzare in caso di fallimento
+     * @param {Function} postSuccess Callback da chimare in caso di successo
+     * @param {Function} postFailure Callback da chimare in caso di fallimento
+     */
+    manageStringResponse(response, successMsg, errorMsg, postSuccess = null, postFailure = null) {
+        if (!response) {
+            if (successMsg)
+                this.simpleSuccess(successMsg);
+            if (postSuccess)
+                postSuccess();
+        }
+        else {
+            if (errorMsg)
+                this.simpleError(errorMsg + ": " + response);
+            if (postFailure)
+                postFailure();
+        }
+    }
+    /**
+     * Metodo helper per gestire in maniera standardizzata una risposta di tipo **boolean**
+     *
+     * @param {string} response Risposta ricevuta dal server
+     * @param {string} successMsg Messaggio da visualizzare in caso di successo
+     * @param {string} errorMsg Messaggio da visualizzare in caso di fallimento
+     * @param {Function} postSuccess Callback da chimare in caso di successo
+     * @param {Function} postFailure Callback da chimare in caso di fallimento
+     */
+    manageStringResponseBool(response, successMsg, errorMsg, postSuccess = null, postFailure = null) {
+        if (response) {
+            if (successMsg)
+                this.simpleSuccess(successMsg);
+            if (postSuccess)
+                postSuccess();
+        }
+        else {
+            if (errorMsg)
+                this.simpleError(errorMsg);
+            if (postFailure)
+                postFailure();
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: MessageService, deps: [{ token: Injector }, { token: i1.BaseLocalization, optional: true }, { token: i2.HashingService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: MessageService, providedIn: "root" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: MessageService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: "root" }]
+        }], ctorParameters: function () { return [{ type: i0.Injector, decorators: [{
+                    type: Inject,
+                    args: [Injector]
+                }] }, { type: i1.BaseLocalization, decorators: [{
+                    type: Optional
+                }] }, { type: i2.HashingService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"extensions.messages.service.js","sourceRoot":"","sources":["../../../../../projects/extensions/src/lib/services/extensions.messages.service.ts"],"names":[],"mappings":"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","sourcesContent":["// Angular\r\nimport { Injectable, Inject, Optional, Injector } from \"@angular/core\";\r\n\r\n// Es\r\nimport { BaseLocalization } from \"@esfaenza/localizations\";\r\n\r\n// Configurazioni\r\nimport { ToastrService } from \"ngx-toastr\";\r\nimport swal from \"sweetalert2\";\r\n\r\n// RXJS\r\nimport { Observable, Subject, of } from \"rxjs\";\r\nimport { filter, first, map, take } from \"rxjs/operators\";\r\n\r\n// Modelli\r\nimport { CallResult } from \"../models/CallResult\";\r\n\r\n// Servizi\r\nimport { AppEmbeddingExtensions } from \"./extensions.embedding.service\";\r\nimport { HashingService } from \"./extensions.hashing.service\";\r\n\r\n/**\r\n * Service che fornisce funzionalità di alert nei tipi fondamentali: success, info, warning e danger\r\n */\r\n@Injectable({ providedIn: \"root\" })\r\nexport class MessageService {\r\n\r\n    /** Oggetto statico in supporto alla localizzazione */\r\n    private loc = {\r\n        'Confirm': { 'en-US': \"Confirm\", 'it-IT': \"Conferma\", },\r\n        'Cancel': { 'en-US': \"Cancel\", 'it-IT': \"Annulla\", },\r\n        'Close': { 'en-US': \"Close\", 'it-IT': \"Chiudi\", },\r\n        'Error': { 'en-US': \"Error\", 'it-IT': \"Errore\", },\r\n        'Info': { 'en-US': \"Info\", 'it-IT': \"Informazione\", },\r\n        'Success': { 'en-US': \"Success\", 'it-IT': \"Successo\", },\r\n        'Warning': { 'en-US': \"Warning\", 'it-IT': \"Attenzione\", }\r\n    };\r\n\r\n    /** Template di un warning con richiesta di conferma */\r\n    private warningSwalWithCancel: any;\r\n\r\n    /** Template di un warning con richiesta di conferma */\r\n    private successSwalWithCancel: any;\r\n\r\n    /** Template di un errore */\r\n    private errorSwal: any;\r\n\r\n    /** Template di un messaggio di successo */\r\n    private successSwal: any;\r\n\r\n    /** Template di un avviso */\r\n    private warningSwal: any;\r\n\r\n    /** Template di un messaggio informativo */\r\n    private infoSwal: any;\r\n\r\n    /** Template di un warning per la sessione scaduta */\r\n    private expiredSessionSwal: any;\r\n\r\n    /** Getter per il servizio dei toast. ngx-toastr è fatta talmente male che la service dev'essere recuperata in questo modo */\r\n    private get toastr(): ToastrService {\r\n        return this.injector.get(ToastrService);\r\n    }\r\n\r\n    /** Supporto all'Embedding */\r\n    Embedded: boolean = false;\r\n    MainWindow: Window = null;\r\n    MessageObserver: Subject<{ event: any, data: any }> = null;\r\n\r\n    /** Costruttore  @ignore */\r\n    public constructor(@Inject(Injector) private injector: Injector, @Optional() private locProvider: BaseLocalization, private hash: HashingService) {\r\n        this.init();\r\n    }\r\n\r\n    public configureEmbeddability(mainWindow: Window, messageObserver: Subject<{ event: any, data: any }>) {\r\n        this.Embedded = true;\r\n        this.MainWindow = mainWindow;\r\n        this.MessageObserver = messageObserver;\r\n    }\r\n\r\n    async init() {\r\n        let LOCALE = this.locProvider ? await this.locProvider.Locale.pipe(first()).toPromise() : 'it-IT';\r\n\r\n        this.expiredSessionSwal = swal.mixin({\r\n            showCancelButton: false,\r\n            confirmButtonText: 'Login',\r\n            customClass: {\r\n                confirmButton: \"btn btn-primary\",\r\n                container: \"app-wrap\",\r\n            },\r\n            buttonsStyling: false,\r\n            reverseButtons: false,\r\n            allowOutsideClick: false,\r\n            icon: \"warning\"\r\n        });\r\n\r\n        this.successSwalWithCancel = swal.mixin({\r\n            title: this.loc[\"Success\"][LOCALE],\r\n            customClass: {\r\n                confirmButton: \"btn btn-primary\",\r\n                cancelButton: \"btn btn-secondary app-margin-right-10\",\r\n                container: \"app-wrap\",\r\n            },\r\n            buttonsStyling: false,\r\n            reverseButtons: true,\r\n            showCancelButton: true,\r\n            confirmButtonText: this.loc[\"Confirm\"][LOCALE],\r\n            cancelButtonText: this.loc[\"Cancel\"][LOCALE],\r\n            icon: \"success\"\r\n        });\r\n\r\n        this.warningSwalWithCancel = swal.mixin({\r\n            title: this.loc[\"Warning\"][LOCALE],\r\n            customClass: {\r\n                confirmButton: \"btn btn-primary\",\r\n                cancelButton: \"btn btn-secondary app-margin-right-10\",\r\n                container: \"app-wrap\",\r\n            },\r\n            buttonsStyling: false,\r\n            reverseButtons: true,\r\n            showCancelButton: true,\r\n            confirmButtonText: this.loc[\"Confirm\"][LOCALE],\r\n            cancelButtonText: this.loc[\"Cancel\"][LOCALE],\r\n            icon: \"warning\"\r\n        });\r\n\r\n        this.warningSwal = swal.mixin({\r\n            title: this.loc[\"Warning\"][LOCALE],\r\n            customClass: {\r\n                confirmButton: \"btn btn-primary\",\r\n                container: \"app-wrap\",\r\n            },\r\n            buttonsStyling: false,\r\n            reverseButtons: true,\r\n            showCancelButton: false,\r\n            confirmButtonText: this.loc[\"Close\"][LOCALE],\r\n            icon: \"warning\"\r\n        });\r\n\r\n        this.successSwal = swal.mixin({\r\n            title: this.loc[\"Success\"][LOCALE],\r\n            customClass: {\r\n                confirmButton: \"btn btn-primary\",\r\n                container: \"app-wrap\",\r\n            },\r\n            buttonsStyling: false,\r\n            reverseButtons: true,\r\n            showCancelButton: false,\r\n            confirmButtonText: this.loc[\"Close\"][LOCALE],\r\n            icon: \"success\"\r\n        });\r\n\r\n        this.errorSwal = swal.mixin({\r\n            title: this.loc[\"Error\"][LOCALE],\r\n            customClass: {\r\n                confirmButton: \"btn btn-primary\",\r\n                container: \"app-wrap\",\r\n            },\r\n            buttonsStyling: false,\r\n            reverseButtons: true,\r\n            showCancelButton: false,\r\n            confirmButtonText: this.loc[\"Close\"][LOCALE],\r\n            icon: \"error\"\r\n        });\r\n\r\n        this.infoSwal = swal.mixin({\r\n            title: this.loc[\"Info\"][LOCALE],\r\n            customClass: {\r\n                confirmButton: \"btn btn-primary\",\r\n                container: \"app-wrap\",\r\n            },\r\n            buttonsStyling: false,\r\n            reverseButtons: true,\r\n            showCancelButton: false,\r\n            confirmButtonText: this.loc[\"Close\"][LOCALE],\r\n            icon: \"info\"\r\n        });\r\n\r\n    }\r\n\r\n    /**\r\n     * Presentazione di un semplice messaggio di successo\r\n     * \r\n     * Se viene chiamato con le impostazioni di default e toastr è abilitato, viene mostrato al centro\r\n     * Se viene chiamato con override su toastr vuol dire che è una notifica secondaria e appare in alto a destra\r\n     * \r\n     * @param {string} text Testo da mostrare\r\n     * @param {\"toastr\" | \"swal\" | null} secondaryNotificationType Qualora sia una notifica secondaria, ne indica il tipo\r\n     */\r\n    public simpleSuccess(text: string, secondaryNotificationType: \"toastr\" | \"swal\" | null = null, secondaryNotificationTimeout: number = null) {\r\n        if (this.Embedded) {\r\n            this.MainWindow.postMessage({ type: \"alert\", level: 'success', msg: text }, \"*\");\r\n            return;\r\n        }\r\n\r\n        let tos = this.toastrOrSwal(secondaryNotificationType);\r\n\r\n        if (tos == \"swal\") this.successSwal.fire(\"\", text);\r\n        else this.toastr.success(text, null, { positionClass: tos == \"toastr\" ? \"toast-top-right\" : \"toast-top-center\", timeOut: secondaryNotificationTimeout || (tos == \"toastr\" ? 0 : 5000), extendedTimeOut: tos == \"toastr\" ? 0 : 1000 });\r\n    }\r\n\r\n    /**\r\n     * Presentazione di un semplice messaggio di informazione\r\n     * \r\n     * Se viene chiamato con le impostazioni di default e toastr è abilitato, viene mostrato al centro\r\n     * Se viene chiamato con override su toastr vuol dire che è una notifica secondaria e appare in alto a destra\r\n     * \r\n     * @param {string} text Testo da mostrare\r\n     * @param {\"toastr\" | \"swal\" | null} secondaryNotificationType Qualora sia una notifica secondaria, ne indica il tipo\r\n     */\r\n    public simpleInfo(text: string, secondaryNotificationType: \"toastr\" | \"swal\" | null = null, secondaryNotificationTimeout: number = null) {\r\n        if (this.Embedded) {\r\n            this.MainWindow.postMessage({ type: \"alert\", level: 'info', msg: text }, \"*\");\r\n            return;\r\n        }\r\n\r\n        let tos = this.toastrOrSwal(secondaryNotificationType);\r\n\r\n        if (tos == \"swal\") this.infoSwal.fire(\"\", text);\r\n        else this.toastr.info(text, null, { positionClass: tos == \"toastr\" ? \"toast-top-right\" : \"toast-top-center\", timeOut: secondaryNotificationTimeout || (tos == \"toastr\" ? 0 : 5000), extendedTimeOut: tos == \"toastr\" ? 0 : 1000 });\r\n    }\r\n\r\n    /**\r\n     * Presentazione di un semplice messaggio di errore\r\n     * \r\n     * Se viene chiamato con le impostazioni di default e toastr è abilitato, viene mostrato al centro\r\n     * Se viene chiamato con override su toastr vuol dire che è una notifica secondaria e appare in alto a destra\r\n     * \r\n     * @param {string} text Testo da mostrare\r\n     * @param {\"toastr\" | \"swal\" | null} secondaryNotificationType Qualora sia una notifica secondaria, ne indica il tipo\r\n     */\r\n    public simpleError(text: string, secondaryNotificationType: \"toastr\" | \"swal\" | null = null, secondaryNotificationTimeout: number = null) {\r\n        if (this.Embedded) {\r\n            this.MainWindow.postMessage({ type: \"alert\", level: 'error', msg: text }, \"*\");\r\n            return;\r\n        }\r\n\r\n        let tos = this.toastrOrSwal(secondaryNotificationType);\r\n\r\n        if (tos == \"swal\") this.errorSwal.fire(\"\", text);\r\n        else this.toastr.error(text, null, { positionClass: tos == \"toastr\" ? \"toast-top-right\" : \"toast-top-center\", timeOut: secondaryNotificationTimeout || (tos == \"toastr\" ? 0 : 5000), extendedTimeOut: tos == \"toastr\" ? 0 : 1000 });\r\n    }\r\n\r\n    /**\r\n     * Presentazione di un semplice messaggio di avviso\r\n     * \r\n     * Se viene chiamato con le impostazioni di default e toastr è abilitato, viene mostrato al centro\r\n     * Se viene chiamato con override su toastr vuol dire che è una notifica secondaria e appare in alto a destra\r\n     * \r\n     * @param {string} text Testo da mostrare\r\n     * @param {\"toastr\" | \"swal\" | null} secondaryNotificationType Qualora sia una notifica secondaria, ne indica il tipo\r\n     */\r\n    public simpleWarning(text: string, secondaryNotificationType: \"toastr\" | \"swal\" | null = null, secondaryNotificationTimeout: number = null) {\r\n        if (this.Embedded) {\r\n            this.MainWindow.postMessage({ type: \"alert\", level: 'warning', msg: text }, \"*\");\r\n            return;\r\n        }\r\n\r\n        let tos = this.toastrOrSwal(secondaryNotificationType);\r\n\r\n        if (tos == \"swal\") this.warningSwal.fire(\"\", text);\r\n        else this.toastr.warning(text, null, { positionClass: tos == \"toastr\" ? \"toast-top-right\" : \"toast-top-center\", timeOut: secondaryNotificationTimeout || (tos == \"toastr\" ? 0 : 5000), extendedTimeOut: tos == \"toastr\" ? 0 : 1000 });\r\n    }\r\n\r\n    /**\r\n     * Ripulisce tutti i messaggi presenti in un dato momento sullo schermo\r\n     */\r\n    public clearMessages() {\r\n        this.toastr.clear();\r\n        swal.close();\r\n    }\r\n\r\n    /**\r\n     * Mostra un messaggio di avviso con richiesta di conferma\r\n     * \r\n     * @param {string} title Titolo del messaggio\r\n     * @param {string} text Contenuto del messaggio\r\n     * \r\n     * @returns {Promise} Restituisce una Promise col risultato scelto dall'utente (conferma o no)\r\n     */\r\n    public promiseWarningWithChoice(title: string, text: string): Promise<any> {\r\n        return this.warningSwalWithCancel.fire(title, text);\r\n    }\r\n\r\n    /**\r\n     * In base alla configurazione attuale e all'eventuale override per la chiamata del caso indica se bisogna utilizzare toastr o sweetalert\r\n     * \r\n     * @param {\"toastr\" | \"swal\" | null} providerOverride Override alla modalità configurata\r\n     * \r\n     * @returns {\"toastr\" | \"swal\"} Indicazione su che provider di messaggi di avviso debba essere utilizzato\r\n     */\r\n    private toastrOrSwal(providerOverride: \"toastr\" | \"swal\" | null): \"toastr\" | \"swal\" {\r\n        if (providerOverride != null)\r\n            return providerOverride;\r\n        return \"swal\";\r\n    }\r\n\r\n    private GuidRepsonseFunctionsMap: { [id: string]: { onsuccess: Function, onerror: Function } } = {};\r\n\r\n    public simpleWarningWithChoice(title: string, text: string, onsuccess?: Function, onerror?: Function, confirmtext: string = \"\", aborttext: string = '') {\r\n        this.withChoiceBase(\"warning\", title, text, onsuccess, onerror, confirmtext, aborttext)\r\n    }\r\n\r\n    public simpleSuccessWithChoice(title: string, text: string, onsuccess?: Function, onerror?: Function, confirmtext: string = \"\", aborttext: string = '') {\r\n        this.withChoiceBase(\"success\", title, text, onsuccess, onerror, confirmtext, aborttext)\r\n    }\r\n\r\n    private withChoiceBase(level: \"warning\" | \"success\", title: string, text: string, onsuccess?: Function, onerror?: Function, confirmtext: string = \"\", aborttext: string = '') {\r\n        if (this.Embedded) {\r\n            let guid = this.hash.getGUID();\r\n            this.GuidRepsonseFunctionsMap[guid] = { onsuccess, onerror };\r\n            this.MainWindow.postMessage({ type: \"confirm\", level, title, text, guid }, \"*\");\r\n\r\n            // Observe sulla risposta\r\n            console.log(\"Inviata confirm request alla pagina principale, in attesa di risposta...\")\r\n            this.MessageObserver.pipe(filter(event => event?.data?.type == \"confirm-response\" && event?.data?.guid == guid), take(1)).subscribe(event => {\r\n                console.log(\"Event listener su window-message. Risposta pergiunta\");\r\n\r\n                if (event?.data?.result === true)\r\n                    this.GuidRepsonseFunctionsMap[guid].onsuccess();\r\n                else if (event?.data?.result === true)\r\n                    this.GuidRepsonseFunctionsMap[guid].onerror();\r\n            })\r\n        }\r\n        else\r\n            (level == \"warning\" ? this._simpleWarningWithChoice.bind(this) : this._simpleSuccessWithChoice.bind(this))(title, text, onsuccess, onerror, confirmtext, aborttext);\r\n    }\r\n\r\n    /**\r\n     * Mostra un messaggio di avviso con richiesta di conferma e gestisce il risultato chiamato i callback **onsuccess** o **onerror**\r\n     * \r\n     * @param {string} title Titolo del messaggio\r\n     * @param {string} text Contenuto del messaggio\r\n     * @param {Function} onsuccess Callback da chimare su conferma\r\n     * @param {Function} onerror Callback da chimare su errori\r\n     */\r\n    private _simpleWarningWithChoice(title: string, text: string, onconfirm: Function = null, onabort: Function = null, confirmtext: string = \"\", aborttext: string = '') {\r\n        this._simpleWithChoice(this.warningSwalWithCancel, title, text, onconfirm, onabort, confirmtext, aborttext)\r\n    }\r\n\r\n    /**\r\n     * Mostra un messaggio di success con richiesta di conferma e gestisce il risultato chiamato i callback **onconfirm** o **onabort**\r\n     * \r\n     * @param {string} title Titolo del messaggio\r\n     * @param {string} text Contenuto del messaggio\r\n     * @param {Function} onconfirm Callback da chimare su conferma\r\n     * @param {Function} onabort Callback da chimare su annullamento\r\n     * @param {string} confirmtext Testo del pulsante di azione\r\n     * @param {string} aborttext Testo del pulsante di annullamento\r\n     */\r\n    private _simpleSuccessWithChoice(title: string, text: string, onconfirm: Function = null, onabort: Function = null, confirmtext: string = \"\", aborttext: string = '') {\r\n        this._simpleWithChoice(this.successSwalWithCancel, title, text, onconfirm, onabort, confirmtext, aborttext)\r\n    }\r\n\r\n    /**\r\n     * Metodo base per richiedere una scelta all'utente\r\n     * \r\n     * @param {any} swal Swal mixin da utilizzare per visualizzare il messaggio di choice\r\n     * @param {string} title Titolo del messaggio\r\n     * @param {string} text Contenuto del messaggio\r\n     * @param {Function} onconfirm Callback da chimare su conferma\r\n     * @param {Function} onabort Callback da chimare su annullamento\r\n     * @param {string} confirmtext Testo del pulsante di azione\r\n     * @param {string} aborttext Testo del pulsante di annullamento\r\n     */\r\n    private _simpleWithChoice(swal: any, title: string, text: string, onconfirm: Function = null, onabort: Function = null, confirmtext: string = \"\", aborttext: string = ''){\r\n        var configuration = {\r\n            title: title,\r\n            html: text\r\n        };\r\n        if (confirmtext)\r\n            configuration[\"confirmButtonText\"] = confirmtext;\r\n        if (aborttext)\r\n            configuration[\"cancelButtonText\"] = aborttext;\r\n\r\n        swal.fire(configuration).then((result) => {\r\n            if (result.value && onconfirm)\r\n                onconfirm();\r\n            else if (onabort)\r\n                onabort();\r\n        });\r\n    }\r\n\r\n    /**\r\n     * Mostra un messaggio di avviso con richiesta di conferma e gestisce il risultato chiamato i callback **onsuccess** o **onerror**\r\n     * \r\n     * @param {string} title Titolo del messaggio\r\n     * @param {string} text Contenuto del messaggio\r\n     */\r\n    public observableSimpleWarningWithChoice(title: string, text: string): Observable<boolean> {\r\n        return of(this.warningSwalWithCancel.fire(title, text)).pipe(map(t => !!t.value))\r\n    }\r\n\r\n    /**\r\n     * Mostra un messaggio di avviso che la sessione corrente è scaduta e propone all'utente di navigare al login. Qualora l'utente decidesse di farlo \r\n     * verrà chiamata la funzione di callback **onnavigate\r\n     * \r\n     * @param {string} title Titolo del messaggio\r\n     * @param {string} text Contenuto del messaggio\r\n     * @param {Function} onnavigate Callback da chimare su navigazione in corso\r\n     */\r\n    public expiredSessionMessage(title: string, text: string, onnavigate: Function = null) {\r\n        this.expiredSessionSwal.fire(title, text).then((result) => {\r\n            if (result.value && onnavigate)\r\n                onnavigate();\r\n        });\r\n    }\r\n\r\n    /**\r\n     * Metodo helper per gestire in maniera standardizzata una risposta di tipo **CallResult**\r\n     * \r\n     * @param {CallResult} response Risposta ricevuta dal server\r\n     * @param {string} successMsg Messaggio da visualizzare in caso di successo\r\n     * @param {string} errorMsg Messaggio da visualizzare in caso di fallimento\r\n     * @param {Function} postSuccess Callback da chimare in caso di successo\r\n     * @param {Function} postFailure Callback da chimare in caso di fallimento\r\n     */\r\n    public manageCallResultResponse(response: CallResult, successMsg: string, errorMsg: string, postSuccess: Function = null, postFailure: Function = null) {\r\n        let anyReponse = <any>response;\r\n        if (response.success || anyReponse.Success) {\r\n            if (response.haswarning || anyReponse.HasWarning)\r\n                this.simpleWarning(response.warning || anyReponse.Warning);\r\n\r\n            else if (successMsg)\r\n                this.simpleSuccess(successMsg);\r\n\r\n            if (postSuccess) postSuccess();\r\n        } else {\r\n            this.simpleError((errorMsg ? errorMsg + \": \" : \"\") + ((response.haserror || anyReponse.HasError) ? (response.error || anyReponse.Error) : '[NO ERR.]'));\r\n\r\n            if (postFailure) postFailure();\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Metodo helper per gestire in maniera standardizzata una risposta di tipo **string**, considerando che:\r\n     * \r\n     * Stringa vuota --> Tutto bene\r\n     * \r\n     * Stringa piena --> Questo è il messaggio d'errore per cui la chiamata è fallita\r\n     * \r\n     * @param {string} response Risposta ricevuta dal server\r\n     * @param {string} successMsg Messaggio da visualizzare in caso di successo\r\n     * @param {string} errorMsg Messaggio da visualizzare in caso di fallimento\r\n     * @param {Function} postSuccess Callback da chimare in caso di successo\r\n     * @param {Function} postFailure Callback da chimare in caso di fallimento\r\n     */\r\n    public manageStringResponse(response: string, successMsg: string, errorMsg: string, postSuccess: Function = null, postFailure: Function = null) {\r\n        if (!response) {\r\n            if (successMsg)\r\n                this.simpleSuccess(successMsg);\r\n\r\n            if (postSuccess) postSuccess();\r\n        } else {\r\n            if (errorMsg)\r\n                this.simpleError(errorMsg + \": \" + response);\r\n\r\n            if (postFailure) postFailure();\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Metodo helper per gestire in maniera standardizzata una risposta di tipo **boolean**\r\n     * \r\n     * @param {string} response Risposta ricevuta dal server\r\n     * @param {string} successMsg Messaggio da visualizzare in caso di successo\r\n     * @param {string} errorMsg Messaggio da visualizzare in caso di fallimento\r\n     * @param {Function} postSuccess Callback da chimare in caso di successo\r\n     * @param {Function} postFailure Callback da chimare in caso di fallimento\r\n     */\r\n    public manageStringResponseBool(response: boolean, successMsg: string, errorMsg: string, postSuccess: Function = null, postFailure: Function = null) {\r\n        if (response) {\r\n            if (successMsg)\r\n                this.simpleSuccess(successMsg);\r\n\r\n            if (postSuccess) postSuccess();\r\n        } else {\r\n            if (errorMsg)\r\n                this.simpleError(errorMsg);\r\n\r\n            if (postFailure) postFailure();\r\n        }\r\n    }\r\n}"]}