@esfaenza/extensions 12.2.8 → 12.2.12

package/lib/models/ExtensionsModuleConfig.d.ts

@@ -1,3 +1,6 @@
+import { Type } from "@angular/core";
+import { BaseStorageProvider } from "./providers/base/BaseStorageProvider";
+import { BaseSessionRetriever } from "./session/base/BaseSessionRetriever";
 /**
  * Classe di configurazione per il modulo di estensione
  */
@@ -18,4 +21,12 @@ export declare class ExtensionsModuleConfig {
      * Prefisso delle searchView che serve per storicizzarle evitando di tirarsi in memoria anche tutti gli oggetti. Se vuoto viene supposto 'Hot'
      */
     appsearch_prefix: string;
+    /**
+     * Classe che si deve occupare per generare un ID univoco di sessione in base al quale verranno salvate le preferenze
+     */
+    sessionRetriever?: Type<BaseSessionRetriever>;
+    /**
+     * Classe che si deve occupare di salvare fisicamente le preferenze su un supporto fisico, sia esso un DB, un localStorage o whatever
+     */
+    storageProvider?: Type<BaseStorageProvider>;
 }

package/lib/models/providers/base/BaseStorageProvider.d.ts

@@ -0,0 +1,65 @@
+import { Observable } from "rxjs";
+import { BaseSessionRetriever } from "../../session/base/BaseSessionRetriever";
+/**
+ * Classe che gestisce la scrittura delle informazioni nello store locale.
+ * Questo store locale potrebbe essere il localStorage (implementazione di default data dal **DefaultStorageProvider**),
+ * oppure un'implementazione custom facente capo a un DB esterno.
+ *
+ * In questo ultimo caso però sarà necessario implementarsi un proprio **BaseSessionRetriever**
+ * che generi una chiave univoca di sessione su cui tutte le operazioni di questa classe saranno eseguite
+ */
+export declare abstract class BaseStorageProvider {
+    protected session: BaseSessionRetriever;
+    /** @ignore Costruttore */
+    constructor(session: BaseSessionRetriever);
+    /**
+     * Imposta un oggetto data una chiave
+     *
+     * @param {string} key Chiave per cui impostare il valore serializzato dell'oggetto **value**
+     * @param {T} value Valore da serializzare e salvare
+     *
+     * @returns {Observable<boolean>} Observable che viene risolto quando l'operazione di salvataggio termina.
+     * Restituisce true se l'operazione è andata a buon fine, false altrimenti
+     */
+    abstract setItem<T>(key: string, value: T): Observable<boolean>;
+    /**
+     * Risolve un oggetto data una chiave
+     *
+     * @param {string} key Chiave per cui risolvere e recuperare l'oggetto
+     *
+     * @returns {Observable<T>} Observable che viene risolto quando l'oggetto viene trovato e recuperato.
+     * Restituisce "null" se l'oggetto non viene trovato o se ci sono problemi a recuperarlo
+     */
+    abstract getItem<T>(key: string): Observable<T>;
+    /**
+     * Rimuove un oggetto salvato con una specifica chiave
+     *
+     *
+     * @returns {Observable<T>} Observable che viene risolto quando l'operazione di eliminazione termina.
+     * Restituisce true se l'operazione è andata a buon fine, false altrimenti
+     */
+    abstract removeItem(key: string): Observable<boolean>;
+    /**
+     * Ripulisce completamente lo store locale
+     *
+     * @returns {Observable<boolean>} Observable che viene risolto quando l'operazione di pulizia termina.
+     * Restituisce true se l'operazione è andata a buon fine, false altrimenti
+     */
+    abstract clear(): Observable<boolean>;
+    /**
+     * Ottiene tutte le chiavi salvate nello store locale
+     *
+     * @returns {Observable<{ [index: string]: string; }>} Observable che viene risolto quando l'operazione di recupero dati termina.
+     */
+    abstract getAll(): Observable<{
+        [index: string]: string;
+    }>;
+    /**
+    * Ottiene la chiave "Reale" da utilizzare per la persistenza di una chiave generica
+    *
+    * @param {string} key Chiave da storicizzare
+    *
+    * @returns {string} Unione fra l'identificativo della sessione e la chiave specificata
+    */
+    protected getKey(key: string): string;
+}

package/lib/models/providers/implementation/DefaultStorageProvider.d.ts

@@ -0,0 +1,20 @@
+import { Observable } from "rxjs";
+import { BaseSessionRetriever } from "../../session/base/BaseSessionRetriever";
+import { BaseStorageProvider } from "../base/BaseStorageProvider";
+/** Implementazione di default per la classe **BaseStorageProvider** */
+export declare class DefaultStorageProvider extends BaseStorageProvider {
+    /** @ignore Costruttore */
+    constructor(session: BaseSessionRetriever);
+    /** @ignore Implementazione di Default con localStorage. Identity viene ignorata perché essendo già nel localStorage è già per sito */
+    setItem<T>(key: string, value: T): Observable<boolean>;
+    /** @ignore Implementazione di Default con localStorage. Identity viene ignorata perché essendo già nel localStorage è già per sito */
+    getItem<T>(key: string): Observable<T>;
+    /** @ignore Implementazione di Default con localStorage. Identity viene ignorata perché essendo già nel localStorage è già per sito */
+    removeItem(key: string): Observable<boolean>;
+    /** @ignore Implementazione di Default con localStorage. Identity viene ignorata perché essendo già nel localStorage è già per sito */
+    clear(): Observable<boolean>;
+    /** @ignore Implementazione di Default con localStorage. Identity viene ignorata perché essendo già nel localStorage è già per sito */
+    getAll(): Observable<{
+        [index: string]: string;
+    }>;
+}

package/lib/models/session/base/BaseSessionRetriever.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Classe astratta che si occupa di recuperare l'Id sessione univoco per applicazione ed utente collegato
+ */
+export declare abstract class BaseSessionRetriever {
+    /**
+     * Ottiene un ID sessione
+     *
+     * @returns {string} ID sessione
+     */
+    abstract getSessionKey(): string;
+}

package/lib/models/session/implementation/DefaultSessionRetriever.d.ts

@@ -0,0 +1,18 @@
+import { BaseSessionRetriever } from "../base/BaseSessionRetriever";
+/**
+ * Implementazione di default per la classe **BaseSessionRetriever**
+ */
+export declare class DefaultSessionRetriever extends BaseSessionRetriever {
+    /**
+     * Costruttore
+     *
+     * @ignore
+     */
+    constructor();
+    /**
+     * Ottiene un ID sessione
+     *
+     * @returns {string} ID sessione
+     */
+    getSessionKey(): string;
+}

package/lib/modules/extensions.full.module.d.ts

@@ -9,6 +9,8 @@ import { ExtensionsModuleConfig } from '../models/ExtensionsModuleConfig';
  * MessageService,
  * UtilityService,
  * StorageService,
+ *
+ * con eventuali provider che utilizzano
  */
 export declare class FullExtensionsModule {
     static forRoot(config?: ExtensionsModuleConfig): ModuleWithProviders<FullExtensionsModule>;

package/lib/services/extensions.hashing.service.d.ts

@@ -15,13 +15,21 @@ export declare class HashingService {
      * @param {number} level Livello di ricorsione nel caso venga effettuato l'hash di un oggetto che contiene altri oggetti
      * @param {boolean} navigateFullDepth Indica se navigare l'oggetto per l'intera lunghezza. In caso contrario si ferma al secondo livello
      *
-     * @returns {string} md5 generato per l'oggetto in questione
+     * @returns {string} Hash generato per l'oggetto in questione
      */
-    hashObject(o: any, level?: number, navigateFullDepth?: boolean): string;
+    hashObject(o: any, level?: number, navigateFullDepth?: boolean, precise?: boolean): string;
+    /**
+     * Hash più semplice e più veloce dell'md5, ma meno sicuro
+     *
+     * Vedi https://stackoverflow.com/questions/7616461/generate-a-hash-from-string-in-javascript
+     *
+     * @param {string} str Stringa di cui calcolare l'hash
+     */
+    private simpleHash;
     /**
      * Blacklist dei tipi da ignorare quando si effettua l'hashing degli oggetti
      */
-    private ObjectHashingBlacklist;
+    private objBlacklist;
     /**
      * Genera una stringa che identifica univocamente l'oggetto in questione
      *

package/lib/services/extensions.storage.service.d.ts

@@ -1,14 +1,22 @@
+import { BaseStorageProvider } from "../models/providers/base/BaseStorageProvider";
+import { BaseSessionRetriever } from "../models/session/base/BaseSessionRetriever";
+import { Observable } from "rxjs";
 /**
- * Service che fornisce funzionalità di base per storicizzazione e recupero oggetti dal localStorage
+ * 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 declare class StorageService {
     private APPSEARCH_PREFIX;
+    private _session;
+    private _storage;
     /**
      * Costruttore
      *
      * @ignore
      */
-    constructor(APPSEARCH_PREFIX: string);
+    constructor(APPSEARCH_PREFIX: string, _session: BaseSessionRetriever, _storage: BaseStorageProvider);
     /**
      * 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
@@ -16,28 +24,33 @@ export declare class StorageService {
      * @param {string} storeName Chiave del localStorage in cui storicizzare l'oggetto **itemsContainer**
      * @param {{ items: any[] }} itemsContainer Oggetto da storicizzare
      */
-    setItem(storeName: string, itemsContainer: {
-        items: any[];
-    }): void;
+    setItem<T>(storeName: string, item: T): Observable<boolean>;
     /**
-     * Inserisce un oggetto nel localstorage dopo averlo serializzato
-     *
-     * @param {string} storeName Chiave del localStorage in cui storicizzare l'oggetto **item**
-     * @param {any} item Oggetto da storicizzare
-     */
-    setAny(storeName: string, item: any): void;
-    /**
-     * Recupera un oggetto dal localStorage
+     * Recupera un oggetto dallo Storage Locale
      *
      * @param {string} storeName Chiave del localStorage da cui recuperare l'oggetto
      *
      * @returns {any} Oggetto recuperato e deserializzato
      */
-    getAny(storeName: string): any;
+    getItem<T>(storeName: string): Observable<T>;
+    /**
+     * Ripulisce lo Storage Locale
+     *
+     * @param {string} storeName Chiave del localStorage da ripulire
+     */
+    removeItem(storeName: string): Observable<boolean>;
     /**
-     * Ripulisce il localStorage
+     * Ripulisce lo Storage Locale di ogni cosa salvata
      *
      * @param {string} storeName Chiave del localStorage da ripulire
      */
-    clear(storeName: string): void;
+    clear(): Observable<boolean>;
+    /**
+     * Restituisce tutte le chiavi-valore associate alla sessione corrente
+     *
+     * @returns {Observable<{ [index: string]: string; }>} Risultato della query
+     */
+    getAll(): Observable<{
+        [index: string]: string;
+    }>;
 }

package/package.json

@@ -1,16 +1,16 @@
 {
   "name": "@esfaenza/extensions",
-  "version": "12.2.8",
+  "version": "12.2.12",
   "dependencies": {
     "tslib": "^2.0.0"
   },
   "peerDependencies": {
-    "@angular/common": "~12.2.3",
-    "@angular/core": "~12.2.3",
-    "sweetalert2": "^11.1.4",
-    "ngx-toastr": "^14.1.0",
-    "dayjs": "^1.10.6",
-    "cerialize": "^0.1.18"
+    "@angular/common": "~12.2.12",
+    "@angular/core": "~12.2.12",
+    "sweetalert2": "11.1.9",
+    "ngx-toastr": "14.1.4",
+    "dayjs": "1.10.7",
+    "cerialize": "0.1.18"
   },
   "main": "bundles/esfaenza-extensions.umd.js",
   "module": "fesm2015/esfaenza-extensions.js",

package/public-api.d.ts

@@ -11,3 +11,5 @@ export * from './lib/tokens';
 export * from './lib/models/CallResult';
 export * from './lib/models/CsvHeaders';
 export * from './lib/models/GenericItem';
+export * from './lib/models/providers/base/BaseStorageProvider';
+export * from './lib/models/session/base/BaseSessionRetriever';