@esfaenza/extensions 12.2.13 → 13.1.1

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

@@ -0,0 +1,323 @@
+// Angular
+import { Injectable, Inject, Optional } from "@angular/core";
+import swal from "sweetalert2";
+// Modelli
+import { EXT_LOCALE, EXT_FANCY_ALERTS } from "../tokens";
+import * as i0 from "@angular/core";
+import * as i1 from "ngx-toastr";
+/**
+ * Service che fornisce funzionalità di alert nei tipi fondamentali: success, info, warning e danger
+ */
+export class MessageService {
+    /**
+     * Costruttore
+     *
+     * @ignore
+     */
+    constructor(toastr, FANCY_ALERTS, LOCALE) {
+        this.toastr = toastr;
+        this.FANCY_ALERTS = FANCY_ALERTS;
+        this.LOCALE = LOCALE;
+        /**
+         * Oggetto statico in supporto alla localizzazione
+         */
+        this.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", }
+        };
+        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.warningSwalWithCancel = swal.mixin({
+            title: this.loc["Warning"][this.LOCALE ?? 'it-IT'],
+            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"][this.LOCALE ?? 'it-IT'],
+            cancelButtonText: this.loc["Cancel"][this.LOCALE ?? 'it-IT'],
+            icon: "warning"
+        });
+        this.warningSwal = swal.mixin({
+            title: this.loc["Warning"][this.LOCALE ?? 'it-IT'],
+            customClass: {
+                confirmButton: "btn btn-primary",
+                container: "app-wrap",
+            },
+            buttonsStyling: false,
+            reverseButtons: true,
+            showCancelButton: false,
+            confirmButtonText: this.loc["Close"][this.LOCALE ?? 'it-IT'],
+            icon: "warning"
+        });
+        this.successSwal = swal.mixin({
+            title: this.loc["Success"][this.LOCALE ?? 'it-IT'],
+            customClass: {
+                confirmButton: "btn btn-primary",
+                container: "app-wrap",
+            },
+            buttonsStyling: false,
+            reverseButtons: true,
+            showCancelButton: false,
+            confirmButtonText: this.loc["Close"][this.LOCALE ?? 'it-IT'],
+            icon: "success"
+        });
+        this.errorSwal = swal.mixin({
+            title: this.loc["Error"][this.LOCALE ?? 'it-IT'],
+            customClass: {
+                confirmButton: "btn btn-primary",
+                container: "app-wrap",
+            },
+            buttonsStyling: false,
+            reverseButtons: true,
+            showCancelButton: false,
+            confirmButtonText: this.loc["Close"][this.LOCALE ?? 'it-IT'],
+            icon: "error"
+        });
+        this.infoSwal = swal.mixin({
+            title: this.loc["Info"][this.LOCALE ?? 'it-IT'],
+            customClass: {
+                confirmButton: "btn btn-primary",
+                container: "app-wrap",
+            },
+            buttonsStyling: false,
+            reverseButtons: true,
+            showCancelButton: false,
+            confirmButtonText: this.loc["Close"][this.LOCALE ?? 'it-IT'],
+            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) {
+        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: 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) {
+        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: 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) {
+        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: 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) {
+        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: 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 this.FANCY_ALERTS == null ? "swal" : this.FANCY_ALERTS ? "swal" : "toastr";
+    }
+    /**
+     * 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, onsuccess = null, onerror = null) {
+        this.warningSwalWithCancel.fire(title, text).then((result) => {
+            if (result.value && onsuccess)
+                onsuccess();
+            else if (onerror)
+                onerror();
+        });
+    }
+    /**
+     * 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) {
+        if (response.success) {
+            if (successMsg)
+                this.simpleSuccess(successMsg);
+            if (postSuccess)
+                postSuccess();
+        }
+        else if (response.haserror) {
+            this.simpleError((errorMsg ? errorMsg + ": " : "") + response.error);
+            if (postFailure)
+                postFailure();
+        }
+        else if (response.haswarning) {
+            this.simpleWarning(response.warning);
+        }
+    }
+    /**
+     * 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();
+        }
+    }
+}
+MessageService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: MessageService, deps: [{ token: i1.ToastrService }, { token: EXT_FANCY_ALERTS, optional: true }, { token: EXT_LOCALE, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+MessageService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: MessageService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: MessageService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.ToastrService }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [EXT_FANCY_ALERTS]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [EXT_LOCALE]
+                }] }]; } });
+//# 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 } from \"@angular/core\";\r\n\r\n// Configurazioni\r\nimport { ToastrService } from \"ngx-toastr\";\r\nimport swal from \"sweetalert2\";\r\n\r\n// Modelli\r\nimport { EXT_LOCALE, EXT_FANCY_ALERTS } from \"../tokens\";\r\nimport { CallResult } from \"../models/CallResult\";\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()\r\nexport class MessageService {\r\n\r\n    /**\r\n     * Oggetto statico in supporto alla localizzazione\r\n     */\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    /**\r\n     * Template di un warning con richiesta di conferma\r\n     */\r\n    private warningSwalWithCancel: any;\r\n\r\n    /**\r\n     * Template di un errore\r\n     */\r\n    private errorSwal: any;\r\n\r\n    /**\r\n     * Template di un messaggio di successo\r\n     */\r\n    private successSwal: any;\r\n\r\n    /**\r\n     * Template di un avviso\r\n     */\r\n    private warningSwal: any;\r\n\r\n    /**\r\n     * Template di un messaggio informativo\r\n     */\r\n    private infoSwal: any;\r\n\r\n    /**\r\n     * Template di un warning per la sessione scaduta\r\n     */\r\n    private expiredSessionSwal: any;\r\n\r\n    /**\r\n     * Costruttore \r\n     * \r\n     * @ignore\r\n     */\r\n    public constructor(private toastr: ToastrService, @Optional() @Inject(EXT_FANCY_ALERTS) private FANCY_ALERTS: boolean, @Optional() @Inject(EXT_LOCALE) private LOCALE: string) {\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.warningSwalWithCancel = swal.mixin({\r\n            title: this.loc[\"Warning\"][this.LOCALE ?? 'it-IT'],\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\"][this.LOCALE ?? 'it-IT'],\r\n            cancelButtonText: this.loc[\"Cancel\"][this.LOCALE ?? 'it-IT'],\r\n            icon: \"warning\"\r\n        });\r\n\r\n        this.warningSwal = swal.mixin({\r\n            title: this.loc[\"Warning\"][this.LOCALE ?? 'it-IT'],\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\"][this.LOCALE ?? 'it-IT'],\r\n            icon: \"warning\"\r\n        });\r\n\r\n        this.successSwal = swal.mixin({\r\n            title: this.loc[\"Success\"][this.LOCALE ?? 'it-IT'],\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\"][this.LOCALE ?? 'it-IT'],\r\n            icon: \"success\"\r\n        });\r\n\r\n        this.errorSwal = swal.mixin({\r\n            title: this.loc[\"Error\"][this.LOCALE ?? 'it-IT'],\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\"][this.LOCALE ?? 'it-IT'],\r\n            icon: \"error\"\r\n        });\r\n\r\n        this.infoSwal = swal.mixin({\r\n            title: this.loc[\"Info\"][this.LOCALE ?? 'it-IT'],\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\"][this.LOCALE ?? 'it-IT'],\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) {\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:  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) {\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:  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) {\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:  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) {\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:  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 this.FANCY_ALERTS == null ? \"swal\" : this.FANCY_ALERTS ? \"swal\" : \"toastr\";\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    public simpleWarningWithChoice(title: string, text: string, onsuccess: Function = null, onerror: Function = null) {\r\n        this.warningSwalWithCancel.fire(title, text).then((result) => {\r\n            if (result.value && onsuccess)\r\n                onsuccess();\r\n            else if (onerror)\r\n                onerror();\r\n        });\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        if (response.success) {\r\n            if (successMsg)\r\n                this.simpleSuccess(successMsg);\r\n\r\n            if (postSuccess) postSuccess();\r\n        } else if (response.haserror) {\r\n            this.simpleError((errorMsg ? errorMsg + \": \" : \"\") + response.error);\r\n\r\n            if (postFailure) postFailure();\r\n        }\r\n        else if (response.haswarning) {\r\n            this.simpleWarning(response.warning);\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}"]}

package/esm2020/lib/services/extensions.storage.service.mjs

@@ -0,0 +1,103 @@
+// Angular
+import { Injectable, Inject, Optional } from "@angular/core";
+// Modelli
+import { APPSEARCH_PREFIX } from '../tokens';
+import { tap, first } from "rxjs/operators";
+import * as i0 from "@angular/core";
+import * as i1 from "../models/session/base/BaseSessionRetriever";
+import * as i2 from "../models/providers/base/BaseStorageProvider";
+/**
+ * Service che fornisce funzionalità di base per storicizzazione e recupero oggetti dallo Storage Locale
+ *
+ * N.B: In ogni chiamata è presente l'operatore rxjs **first()** per far sì che a prescindere dall'implementazione utente/default gli
+ * observable effettuino l'unsubscribe automaticamente terminata la prima operazine
+ */
+export class StorageService {
+    /**
+     * Costruttore
+     *
+     * @ignore
+     */
+    constructor(APPSEARCH_PREFIX, _session, _storage) {
+        this.APPSEARCH_PREFIX = APPSEARCH_PREFIX;
+        this._session = _session;
+        this._storage = _storage;
+    }
+    /**
+     * Inserisce un oggetto che funga da contenitore di oggetti nel local storage, ripulendone gli oggetti (supponendo che sia una view di ricerca) e marcandolo come
+     * salvato, in modo che quando viene recuperato il sistema non pensi che sia un oggetto vuoto ma che sappia che gli oggetti son stati ripuliti per risparmiare spazio
+     *
+     * @param {string} storeName Chiave del localStorage in cui storicizzare l'oggetto **itemsContainer**
+     * @param {{ items: any[] }} itemsContainer Oggetto da storicizzare
+     */
+    setItem(storeName, item) {
+        var finalItem;
+        //Se sto salvando un oggetto con "items" e "page" vuol dire che è un appsearch, la ripulisco
+        if (item.items && item.page) {
+            finalItem = JSON.parse(JSON.stringify(item));
+            finalItem.items = [];
+            finalItem.savedstate = true;
+            finalItem.savedprefix = this.APPSEARCH_PREFIX || 'Hot';
+        }
+        else
+            finalItem = item;
+        return this._storage.setItem(storeName, finalItem).pipe(first(), tap(res => {
+            if (res == false)
+                console.error("Impossibile effettuare il salvataggio dell'oggetto all'interno dello Storage Locale per la chiave " + storeName);
+        }));
+    }
+    /**
+     * Recupera un oggetto dallo Storage Locale
+     *
+     * @param {string} storeName Chiave del localStorage da cui recuperare l'oggetto
+     *
+     * @returns {any} Oggetto recuperato e deserializzato
+     */
+    getItem(storeName) {
+        return this._storage.getItem(storeName).pipe(first(), tap(res => {
+            if (res == null)
+                console.warn("Impossibile ottenere l'oggetto salvato con chiave " + storeName);
+        }));
+    }
+    /**
+     * Ripulisce lo Storage Locale
+     *
+     * @param {string} storeName Chiave del localStorage da ripulire
+     */
+    removeItem(storeName) {
+        return this._storage.removeItem(storeName).pipe(first(), tap(res => {
+            if (res == false)
+                console.warn("Impossibile rimuovere l'oggetto salvato con chiave " + storeName);
+        }));
+    }
+    /**
+     * Ripulisce lo Storage Locale di ogni cosa salvata
+     *
+     * @param {string} storeName Chiave del localStorage da ripulire
+     */
+    clear() {
+        return this._storage.clear().pipe(first(), tap(res => {
+            if (res == false)
+                console.warn("Impossibile ripulire lo Storage Locale");
+        }));
+    }
+    /**
+     * Restituisce tutte le chiavi-valore associate alla sessione corrente
+     *
+     * @returns {Observable<{ [index: string]: string; }>} Risultato della query
+     */
+    getAll() {
+        return this._storage.getAll().pipe(first());
+    }
+}
+StorageService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: StorageService, deps: [{ token: APPSEARCH_PREFIX, optional: true }, { token: i1.BaseSessionRetriever }, { token: i2.BaseStorageProvider }], target: i0.ɵɵFactoryTarget.Injectable });
+StorageService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: StorageService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: StorageService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [APPSEARCH_PREFIX]
+                }] }, { type: i1.BaseSessionRetriever }, { type: i2.BaseStorageProvider }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"extensions.storage.service.js","sourceRoot":"","sources":["../../../../../projects/extensions/src/lib/services/extensions.storage.service.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAI7D,UAAU;AACV,OAAO,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAI7C,OAAO,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;;;;AAE5C;;;;;GAKG;AAEH,MAAM,OAAO,cAAc;IAEvB;;;;OAIG;IACH,YAA0D,gBAAwB,EAAU,QAA8B,EAAU,QAA6B;QAAvG,qBAAgB,GAAhB,gBAAgB,CAAQ;QAAU,aAAQ,GAAR,QAAQ,CAAsB;QAAU,aAAQ,GAAR,QAAQ,CAAqB;IAAI,CAAC;IAEtK;;;;;;OAMG;IACI,OAAO,CAAI,SAAiB,EAAE,IAAO;QACxC,IAAI,SAAc,CAAC;QACnB,4FAA4F;QAC5F,IAAU,IAAK,CAAC,KAAK,IAAU,IAAK,CAAC,IAAI,EAAE;YACvC,SAAS,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC;YAC7C,SAAS,CAAC,KAAK,GAAG,EAAE,CAAC;YACrB,SAAS,CAAC,UAAU,GAAG,IAAI,CAAC;YACtB,SAAU,CAAC,WAAW,GAAG,IAAI,CAAC,gBAAgB,IAAI,KAAK,CAAC;SACjE;;YAEG,SAAS,GAAG,IAAI,CAAC;QAErB,OAAO,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,EAAE,GAAG,CAAC,GAAG,CAAC,EAAE;YACvE,IAAI,GAAG,IAAI,KAAK;gBACZ,OAAO,CAAC,KAAK,CAAC,oGAAoG,GAAG,SAAS,CAAC,CAAC;QACxI,CAAC,CAAC,CAAC,CAAC;IACR,CAAC;IAED;;;;;;OAMG;IACI,OAAO,CAAI,SAAiB;QAC/B,OAAO,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAI,SAAS,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,EAAE,GAAG,CAAC,GAAG,CAAC,EAAE;YAC/D,IAAI,GAAG,IAAI,IAAI;gBACX,OAAO,CAAC,IAAI,CAAC,oDAAoD,GAAG,SAAS,CAAC,CAAC;QACvF,CAAC,CAAC,CAAC,CAAC;IACR,CAAC;IAED;;;;OAIG;IACI,UAAU,CAAC,SAAiB;QAC/B,OAAO,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,EAAE,GAAG,CAAC,GAAG,CAAC,EAAE;YAC/D,IAAI,GAAG,IAAI,KAAK;gBACZ,OAAO,CAAC,IAAI,CAAC,qDAAqD,GAAG,SAAS,CAAC,CAAC;QACxF,CAAC,CAAC,CAAC,CAAC;IACR,CAAC;IAED;;;;OAIG;IACI,KAAK;QACR,OAAO,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC,IAAI,CAAC,KAAK,EAAE,EAAE,GAAG,CAAC,GAAG,CAAC,EAAE;YACjD,IAAI,GAAG,IAAI,KAAK;gBACZ,OAAO,CAAC,IAAI,CAAC,wCAAwC,CAAC,CAAC;QAC/D,CAAC,CAAC,CAAC,CAAC;IACR,CAAC;IAED;;;;OAIG;IACI,MAAM;QACT,OAAO,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC;IAChD,CAAC;;2GA/EQ,cAAc,kBAOS,gBAAgB;+GAPvC,cAAc;2FAAd,cAAc;kBAD1B,UAAU;;0BAQM,QAAQ;;0BAAI,MAAM;2BAAC,gBAAgB","sourcesContent":["// Angular\r\nimport { Injectable, Inject, Optional } from \"@angular/core\";\r\nimport { BaseStorageProvider } from \"../models/providers/base/BaseStorageProvider\";\r\nimport { BaseSessionRetriever } from \"../models/session/base/BaseSessionRetriever\";\r\n\r\n// Modelli\r\nimport { APPSEARCH_PREFIX } from '../tokens';\r\n\r\n// RXJS\r\nimport { Observable } from \"rxjs\";\r\nimport { tap, first } from \"rxjs/operators\";\r\n\r\n/**\r\n * Service che fornisce funzionalità di base per storicizzazione e recupero oggetti dallo Storage Locale\r\n * \r\n * N.B: In ogni chiamata è presente l'operatore rxjs **first()** per far sì che a prescindere dall'implementazione utente/default gli \r\n * observable effettuino l'unsubscribe automaticamente terminata la prima operazine\r\n */\r\n@Injectable()\r\nexport class StorageService {\r\n\r\n    /**\r\n     * Costruttore\r\n     * \r\n     * @ignore\r\n     */\r\n    constructor(@Optional() @Inject(APPSEARCH_PREFIX) private APPSEARCH_PREFIX: string, private _session: BaseSessionRetriever, private _storage: BaseStorageProvider) { }\r\n\r\n    /**\r\n     * Inserisce un oggetto che funga da contenitore di oggetti nel local storage, ripulendone gli oggetti (supponendo che sia una view di ricerca) e marcandolo come \r\n     * salvato, in modo che quando viene recuperato il sistema non pensi che sia un oggetto vuoto ma che sappia che gli oggetti son stati ripuliti per risparmiare spazio\r\n     * \r\n     * @param {string} storeName Chiave del localStorage in cui storicizzare l'oggetto **itemsContainer**\r\n     * @param {{ items: any[] }} itemsContainer Oggetto da storicizzare\r\n     */\r\n    public setItem<T>(storeName: string, item: T): Observable<boolean> {\r\n        var finalItem: any;\r\n        //Se sto salvando un oggetto con \"items\" e \"page\" vuol dire che è un appsearch, la ripulisco\r\n        if ((<any>item).items && (<any>item).page) {\r\n            finalItem = JSON.parse(JSON.stringify(item));\r\n            finalItem.items = [];\r\n            finalItem.savedstate = true;\r\n            (<any>finalItem).savedprefix = this.APPSEARCH_PREFIX || 'Hot';\r\n        }\r\n        else\r\n            finalItem = item;\r\n\r\n        return this._storage.setItem(storeName, finalItem).pipe(first(), tap(res => {\r\n            if (res == false)\r\n                console.error(\"Impossibile effettuare il salvataggio dell'oggetto all'interno dello Storage Locale per la chiave \" + storeName);\r\n        }));\r\n    }\r\n\r\n    /**\r\n     * Recupera un oggetto dallo Storage Locale\r\n     * \r\n     * @param {string} storeName Chiave del localStorage da cui recuperare l'oggetto\r\n     * \r\n     * @returns {any} Oggetto recuperato e deserializzato\r\n     */\r\n    public getItem<T>(storeName: string): Observable<T> {\r\n        return this._storage.getItem<T>(storeName).pipe(first(), tap(res => {\r\n            if (res == null)\r\n                console.warn(\"Impossibile ottenere l'oggetto salvato con chiave \" + storeName);\r\n        }));\r\n    }\r\n\r\n    /**\r\n     * Ripulisce lo Storage Locale \r\n     * \r\n     * @param {string} storeName Chiave del localStorage da ripulire\r\n     */\r\n    public removeItem(storeName: string): Observable<boolean> {\r\n        return this._storage.removeItem(storeName).pipe(first(), tap(res => {\r\n            if (res == false)\r\n                console.warn(\"Impossibile rimuovere l'oggetto salvato con chiave \" + storeName);\r\n        }));\r\n    }\r\n\r\n    /**\r\n     * Ripulisce lo Storage Locale di ogni cosa salvata\r\n     * \r\n     * @param {string} storeName Chiave del localStorage da ripulire\r\n     */\r\n    public clear(): Observable<boolean> {\r\n        return this._storage.clear().pipe(first(), tap(res => {\r\n            if (res == false)\r\n                console.warn(\"Impossibile ripulire lo Storage Locale\");\r\n        }));\r\n    }\r\n\r\n    /**\r\n     * Restituisce tutte le chiavi-valore associate alla sessione corrente\r\n     * \r\n     * @returns {Observable<{ [index: string]: string; }>} Risultato della query\r\n     */\r\n    public getAll(): Observable<{ [index: string]: string; }> {\r\n        return this._storage.getAll().pipe(first());\r\n    }\r\n}"]}