diff --git a/EgwCoreLib.Lux.Data/Services/General/IRedisService.cs b/EgwCoreLib.Lux.Data/Services/General/IRedisService.cs
index 42c4df75..193788a5 100644
--- a/EgwCoreLib.Lux.Data/Services/General/IRedisService.cs
+++ b/EgwCoreLib.Lux.Data/Services/General/IRedisService.cs
@@ -9,56 +9,204 @@ namespace EgwCoreLib.Lux.Data.Services.General
     {
         #region Public Methods
 
+        /// <summary>
+        /// Eliminazione chiave su cache REDIS in modalità Async
+        /// </summary>
+        /// <param name="key"></param>
+        /// <returns></returns>
         bool Delete(string key);
 
+        /// <summary>
+        /// Eliminazione chiave su cache REDIS in modalità Async
+        /// </summary>
+        /// <param name="key"></param>
+        /// <returns></returns>
         Task<bool> DeleteAsync(string key);
 
+        /// <summary>
+        /// Elimina chiavi Redis che corrispondono al pattern specificato
+        /// </summary>
+        /// <param name="pattern">Pattern di ricerca (es. "Lux:*" o "*")</param>
+        /// <returns>true se eliminazione completata, false altrimenti</returns>
         Task<bool> FlushPatternAsync(RedisValue pattern);
 
+        /// <summary>
+        /// Recupero stringa da cache REDIS x key indicata in modalità Async
+        /// </summary>
+        /// <param name="key"></param>
+        /// <returns></returns>
         string? Get(string key);
 
+        /// <summary>
+        /// Recupero stringa da cache REDIS x key indicata in modalità Async
+        /// </summary>
+        /// <param name="key"></param>
+        /// <returns></returns>
         Task<string?> GetAsync(string key);
 
+        /// <summary>
+        /// Recupera un campo specifico da una hash REDIS
+        /// </summary>
+        /// <param name="hashKey">Chiave della hash</param>
+        /// <param name="field">Campo da recuperare</param>
+        /// <returns>Valore del campo, o RedisValue.Null se non esiste</returns>
+        Task<RedisValue?> HashGetAsync(string hashKey, string field);
+
+        /// <summary>
+        /// Recupera TUTTI i campi e valori da una hash REDIS
+        /// </summary>
+        /// <param name="hashKey">Chiave della hash</param>
+        /// <returns>Elenco completo di campi e valori, o lista vuota se non esiste</returns>
+        Task<List<HashEntry>> HashGetAllAsync(string hashKey);
+
+
+        /// <summary>
+        /// Pubblicazione messaggio su channel
+        /// </summary>
+        /// <param name="channel"></param>
+        /// <param name="message"></param>
+        /// <returns></returns>
         long Publish(string channel, string message);
 
+        /// <summary>
+        /// Pubblicazione messaggio su channel in modalità async
+        /// </summary>
+        /// <param name="channel"></param>
+        /// <param name="message"></param>
+        /// <returns></returns>
         Task<long> PublishAsync(string channel, string message);
 
+        /// <summary>
+        /// Conteggio elementi in QUEUE (FIFO)
+        /// </summary>
+        /// <param name="queueName"></param>
         long QueueCount(RedisKey queueName);
 
+        /// <summary>
+        /// Conteggio elementi in QUEUE (FIFO)
+        /// </summary>
+        /// <param name="queueName"></param>
         Task<long> QueueCountAsync(RedisKey queueName);
 
+        /// <summary>
+        /// Recupero list di TUTTI i valori in QUEUE (FIFO) senza eliminare
+        /// </summary>
+        /// <param name="queueName"></param>
+        /// <param name="maxElem">num max di elementi da recuperare</param>
         List<RedisValue> QueueListAll(RedisKey queueName);
 
+        /// <summary>
+        /// Recupero list di TUTTI i valori in QUEUE (FIFO) senza eliminare
+        /// </summary>
+        /// <param name="queueName"></param>
+        /// <param name="maxElem">num max di elementi da recuperare</param>
         Task<List<RedisValue>> QueueListAllAsync(RedisKey queueName);
 
+        /// <summary>
+        /// Recupero valore in QUEUE (FIFO)
+        /// </summary>
+        /// <param name="queueName"></param>
         RedisValue QueuePop(RedisKey queueName);
 
+        /// <summary>
+        /// Recupero list di TUTTI i valori in QUEUE (FIFO) eliminandoli dalla coda
+        /// </summary>
+        /// <param name="queueName"></param>
         List<RedisValue> QueuePopAll(RedisKey queueName);
 
+        /// <summary>
+        /// Recupero list di TUTTI i valori in QUEUE (FIFO) eliminandoli dalla coda in modo Async
+        /// </summary>
+        /// <param name="queueName"></param>
         Task<List<RedisValue>> QueuePopAllAsync(RedisKey queueName);
 
+        /// <summary>
+        /// Recupero valore in QUEUE (FIFO) Async
+        /// </summary>
+        /// <param name="queueName"></param>
         Task<RedisValue> QueuePopAsync(RedisKey queueName);
 
+        /// <summary>
+        /// Recupero una list di valori in QUEUE (FIFO)
+        /// </summary>
+        /// <param name="queueName"></param>
+        /// <param name="maxElem">num max di elementi da recuperare</param>
         List<RedisValue> QueuePopList(RedisKey queueName, int maxElem);
 
+        /// <summary>
+        /// Recupero una list di valori in QUEUE (FIFO)
+        /// </summary>
+        /// <param name="queueName"></param>
+        /// <param name="maxElem">num max di elementi da recuperare</param>
         Task<List<RedisValue>> QueuePopListAsync(RedisKey queueName, int maxElem);
 
+        /// <summary>
+        /// Scrittura valore in QUEUE (FIFO)
+        /// </summary>
+        /// <param name="queueName"></param>
+        /// <param name="value"></param>
         long QueuePush(RedisKey queueName, RedisValue value);
 
+        /// <summary>
+        /// Scrittura valore in QUEUE (FIFO)
+        /// </summary>
+        /// <param name="queueName"></param>
+        /// <param name="value"></param>
         Task<long> QueuePushAsync(RedisKey queueName, RedisValue value);
 
+        /// <summary>
+        /// Rimuove un valore specifico dalla queue Redis (FIFO)
+        /// </summary>
+        /// <param name="queueName">Nome della lista</param>
+        /// <param name="value">Valore da rimuovere</param>
+        /// <returns>Numero di elementi rimossi</returns>
         long QueueRemove(RedisKey queueName, RedisValue value);
 
+        /// <summary>
+        /// Rimuove un valore specifico dalla queue Redis (FIFO) Async
+        /// </summary>
+        /// <param name="queueName">Nome della lista</param>
+        /// <param name="value">Valore da rimuovere</param>
+        /// <returns>Numero di elementi rimossi</returns>
         Task<long> QueueRemoveAsync(RedisKey queueName, RedisValue value);
 
+        /// <summary>
+        /// Reset della coda
+        /// </summary>
+        /// <param name="queueName"></param>
+        /// <returns></returns>
         bool QueueReset(RedisKey queueName);
 
+        /// <summary>
+        /// Reset della coda Async
+        /// </summary>
+        /// <param name="queueName"></param>
+        /// <returns></returns>
         Task<bool> QueueResetAsync(RedisKey queueName);
 
+        /// <summary>
+        /// Scrittura string su cache REDIS in modalità Async
+        /// </summary>
+        /// <param name="key"></param>
+        /// <param name="value"></param>
+        /// <param name="tsExpiry"></param>
+        /// <returns></returns>
         bool Set(string key, string value, TimeSpan? expiry = null);
 
+        /// <summary>
+        /// Scrittura string su cache REDIS in modalità Async
+        /// </summary>
+        /// <param name="key"></param>
+        /// <param name="value"></param>
+        /// <param name="tsExpiry"></param>
+        /// <returns></returns>
         Task<bool> SetAsync(string key, string value, TimeSpan? expiry = null);
 
+        /// <summary>
+        /// Sottoscrizione canale REDIS + handler esecuzione
+        /// </summary>
+        /// <param name="channel"></param>
+        /// <param name="handler"></param>
         void Subscribe(string channel, Action<RedisChannel, RedisValue> handler);
 
         #endregion Public Methods
diff --git a/EgwCoreLib.Lux.Data/Services/General/ProdService.cs b/EgwCoreLib.Lux.Data/Services/General/ProdService.cs
index 6eb36941..c0278bf4 100644
--- a/EgwCoreLib.Lux.Data/Services/General/ProdService.cs
+++ b/EgwCoreLib.Lux.Data/Services/General/ProdService.cs
@@ -19,7 +19,6 @@ namespace EgwCoreLib.Lux.Data.Services.General
         {
             // conf redis service
             _redisService = redisService;
-            _db = _redisConn.GetDatabase();
             chPub = _config.GetValue<string>("ServerConf:ChannelPub") ?? "";
             Log.Info($"ProdService | Init OK");
         }
@@ -300,13 +299,13 @@ namespace EgwCoreLib.Lux.Data.Services.General
         public async Task UpdateQueueAsync(Constants.EXECENVIRONMENTS cEnvir, string hashKey)
         {
             // recupero info accessorie da redis
-            var tipo = await _db.HashGetAsync(hashKey, "tipo");
+            var tipo = await _redisService.HashGetAsync(hashKey, "tipo");
 
             // verifico SE si tratta di un create/estimate e nel caso processo coda req x sistemare
-            if (!tipo.IsNull && !string.IsNullOrEmpty(tipo))
+            if (tipo != null && !string.IsNullOrEmpty(tipo))
             {
                 string rKey = "";
-                var UID = await _db.HashGetAsync(hashKey, "UID");
+                var UID = await _redisService.HashGetAsync(hashKey, "UID");
                 var parti = ((string)tipo).Split('-');
                 if (parti.Length == 2)
                 {
@@ -347,7 +346,6 @@ namespace EgwCoreLib.Lux.Data.Services.General
         #region Private Fields
 
         private static Logger Log = LogManager.GetCurrentClassLogger();
-        private readonly IDatabase _db;
         private readonly IRedisService _redisService;
 
         private readonly string chPub = "";
diff --git a/EgwCoreLib.Lux.Data/Services/General/RedisService.cs b/EgwCoreLib.Lux.Data/Services/General/RedisService.cs
index d6fcf817..e46478eb 100644
--- a/EgwCoreLib.Lux.Data/Services/General/RedisService.cs
+++ b/EgwCoreLib.Lux.Data/Services/General/RedisService.cs
@@ -32,10 +32,8 @@ namespace EgwCoreLib.Lux.Data.Services.General
         #region Public Methods
 
         /// <summary>
-        /// Eliminazione chiave su cache REDIS in modalità Async
+        /// <inheritdoc />
         /// </summary>
-        /// <param name="key"></param>
-        /// <returns></returns>
         public bool Delete(string key)
         {
             Log.Trace($"Set request for {key}");
@@ -43,10 +41,8 @@ namespace EgwCoreLib.Lux.Data.Services.General
         }
 
         /// <summary>
-        /// Eliminazione chiave su cache REDIS in modalità Async
+        /// <inheritdoc />
         /// </summary>
-        /// <param name="key"></param>
-        /// <returns></returns>
         public async Task<bool> DeleteAsync(string key)
         {
             Log.Trace($"SetAsync request for {key}");
@@ -54,10 +50,8 @@ namespace EgwCoreLib.Lux.Data.Services.General
         }
 
         /// <summary>
-        /// Elimina chiavi Redis che corrispondono al pattern specificato
+        /// <inheritdoc />
         /// </summary>
-        /// <param name="pattern">Pattern di ricerca (es. "Lux:*" o "*")</param>
-        /// <returns>true se eliminazione completata, false altrimenti</returns>
         public async Task<bool> FlushPatternAsync(RedisValue pattern)
         {
             try
@@ -105,10 +99,8 @@ namespace EgwCoreLib.Lux.Data.Services.General
         }
 
         /// <summary>
-        /// Recupero stringa da cache REDIS x key indicata in modalità Async
+        /// <inheritdoc />
         /// </summary>
-        /// <param name="key"></param>
-        /// <returns></returns>
         public string? Get(string key)
         {
             Log.Trace($"Get request for {key}");
@@ -117,10 +109,8 @@ namespace EgwCoreLib.Lux.Data.Services.General
         }
 
         /// <summary>
-        /// Recupero stringa da cache REDIS x key indicata in modalità Async
+        /// <inheritdoc />
         /// </summary>
-        /// <param name="key"></param>
-        /// <returns></returns>
         public async Task<string?> GetAsync(string key)
         {
             Log.Trace($"GetAsync request for {key}");
@@ -129,11 +119,27 @@ namespace EgwCoreLib.Lux.Data.Services.General
         }
 
         /// <summary>
-        /// Pubblicazione messaggio su channel
+        /// <inheritdoc />
+        /// </summary>
+        public async Task<List<HashEntry>> HashGetAllAsync(string hashKey)
+        {
+            Log.Trace($"HashGetAllAsync request for {hashKey}");
+            var results = await _db.HashGetAllAsync(hashKey);
+            return results.ToList();
+        }
+
+        /// <summary>
+        /// <inheritdoc />
+        /// </summary>
+        public async Task<RedisValue?> HashGetAsync(string hashKey, string field)
+        {
+            Log.Trace($"HashGetAsync request for {hashKey}.{field}");
+            return await _db.HashGetAsync(hashKey, field);
+        }
+
+        /// <summary>
+        /// <inheritdoc />
         /// </summary>
-        /// <param name="channel"></param>
-        /// <param name="message"></param>
-        /// <returns></returns>
         public long Publish(string channel, string message)
         {
             Log.Trace($"Publish: channel {channel}");
@@ -143,11 +149,8 @@ namespace EgwCoreLib.Lux.Data.Services.General
         }
 
         /// <summary>
-        /// Pubblicazione messaggio su channel in modalità async
+        /// <inheritdoc />
         /// </summary>
-        /// <param name="channel"></param>
-        /// <param name="message"></param>
-        /// <returns></returns>
         public async Task<long> PublishAsync(string channel, string message)
         {
             Log.Trace($"PublishAsync: channel {channel}");
@@ -157,28 +160,24 @@ namespace EgwCoreLib.Lux.Data.Services.General
         }
 
         /// <summary>
-        /// Conteggio elementi in QUEUE (FIFO)
+        /// <inheritdoc />
         /// </summary>
-        /// <param name="queueName"></param>
         public long QueueCount(RedisKey queueName)
         {
             return _db.ListLength(queueName);
         }
 
         /// <summary>
-        /// Conteggio elementi in QUEUE (FIFO)
+        /// <inheritdoc />
         /// </summary>
-        /// <param name="queueName"></param>
         public async Task<long> QueueCountAsync(RedisKey queueName)
         {
             return await _db.ListLengthAsync(queueName);
         }
 
         /// <summary>
-        /// Recupero list di TUTTI i valori in QUEUE (FIFO) senza eliminare
+        /// <inheritdoc />
         /// </summary>
-        /// <param name="queueName"></param>
-        /// <param name="maxElem">num max di elementi da recuperare</param>
         public List<RedisValue> QueueListAll(RedisKey queueName)
         {
             // lettura + reset in blocco
@@ -187,10 +186,8 @@ namespace EgwCoreLib.Lux.Data.Services.General
         }
 
         /// <summary>
-        /// Recupero list di TUTTI i valori in QUEUE (FIFO) senza eliminare
+        /// <inheritdoc />
         /// </summary>
-        /// <param name="queueName"></param>
-        /// <param name="maxElem">num max di elementi da recuperare</param>
         public async Task<List<RedisValue>> QueueListAllAsync(RedisKey queueName)
         {
             // lettura + reset in blocco
@@ -199,19 +196,16 @@ namespace EgwCoreLib.Lux.Data.Services.General
         }
 
         /// <summary>
-        /// Recupero valore in QUEUE (FIFO)
+        /// <inheritdoc />
         /// </summary>
-        /// <param name="queueName"></param>
         public RedisValue QueuePop(RedisKey queueName)
         {
             return _db.ListLeftPop(queueName);
         }
 
         /// <summary>
-        /// Recupero list di TUTTI i valori in QUEUE (FIFO) eliminandoli dalla coda
+        /// <inheritdoc />
         /// </summary>
-        /// <param name="queueName"></param>
-        /// <param name="maxElem">num max di elementi da recuperare</param>
         public List<RedisValue> QueuePopAll(RedisKey queueName)
         {
             // lettura + reset in blocco
@@ -224,10 +218,8 @@ namespace EgwCoreLib.Lux.Data.Services.General
         }
 
         /// <summary>
-        /// Recupero list di TUTTI i valori in QUEUE (FIFO) eliminandoli dalla coda in modo Async
+        /// <inheritdoc />
         /// </summary>
-        /// <param name="queueName"></param>
-        /// <param name="maxElem">num max di elementi da recuperare</param>
         public async Task<List<RedisValue>> QueuePopAllAsync(RedisKey queueName)
         {
             // lettura + reset in blocco
@@ -241,19 +233,16 @@ namespace EgwCoreLib.Lux.Data.Services.General
         }
 
         /// <summary>
-        /// Recupero valore in QUEUE (FIFO) Async
+        /// <inheritdoc />
         /// </summary>
-        /// <param name="queueName"></param>
         public async Task<RedisValue> QueuePopAsync(RedisKey queueName)
         {
             return await _db.ListLeftPopAsync(queueName);
         }
 
         /// <summary>
-        /// Recupero una list di valori in QUEUE (FIFO)
+        /// <inheritdoc />
         /// </summary>
-        /// <param name="queueName"></param>
-        /// <param name="maxElem">num max di elementi da recuperare</param>
         public List<RedisValue> QueuePopList(RedisKey queueName, int maxElem)
         {
             // nuovo metodo con rimozione
@@ -268,10 +257,8 @@ namespace EgwCoreLib.Lux.Data.Services.General
         }
 
         /// <summary>
-        /// Recupero una list di valori in QUEUE (FIFO)
+        /// <inheritdoc />
         /// </summary>
-        /// <param name="queueName"></param>
-        /// <param name="maxElem">num max di elementi da recuperare</param>
         public async Task<List<RedisValue>> QueuePopListAsync(RedisKey queueName, int maxElem)
         {
             // nuovo metodo con rimozione
@@ -286,10 +273,8 @@ namespace EgwCoreLib.Lux.Data.Services.General
         }
 
         /// <summary>
-        /// Scrittura valore in QUEUE (FIFO)
+        /// <inheritdoc />
         /// </summary>
-        /// <param name="queueName"></param>
-        /// <param name="value"></param>
         public long QueuePush(RedisKey queueName, RedisValue value)
         {
             long qLen = _db.ListRightPush(queueName, value);
@@ -297,10 +282,8 @@ namespace EgwCoreLib.Lux.Data.Services.General
         }
 
         /// <summary>
-        /// Scrittura valore in QUEUE (FIFO)
+        /// <inheritdoc />
         /// </summary>
-        /// <param name="queueName"></param>
-        /// <param name="value"></param>
         public async Task<long> QueuePushAsync(RedisKey queueName, RedisValue value)
         {
             long qLen = await _db.ListRightPushAsync(queueName, value);
@@ -308,11 +291,8 @@ namespace EgwCoreLib.Lux.Data.Services.General
         }
 
         /// <summary>
-        /// Rimuove un valore specifico dalla queue Redis (FIFO)
+        /// <inheritdoc />
         /// </summary>
-        /// <param name="queueName">Nome della lista</param>
-        /// <param name="value">Valore da rimuovere</param>
-        /// <returns>Numero di elementi rimossi</returns>
         public long QueueRemove(RedisKey queueName, RedisValue value)
         {
             // count = 0 → rimuove TUTTE le occorrenze del valore
@@ -320,11 +300,8 @@ namespace EgwCoreLib.Lux.Data.Services.General
         }
 
         /// <summary>
-        /// Rimuove un valore specifico dalla queue Redis (FIFO)
+        /// <inheritdoc />
         /// </summary>
-        /// <param name="queueName">Nome della lista</param>
-        /// <param name="value">Valore da rimuovere</param>
-        /// <returns>Numero di elementi rimossi</returns>
         public async Task<long> QueueRemoveAsync(RedisKey queueName, RedisValue value)
         {
             // count = 0 → rimuove TUTTE le occorrenze del valore
@@ -332,10 +309,8 @@ namespace EgwCoreLib.Lux.Data.Services.General
         }
 
         /// <summary>
-        /// Reset della coda
+        /// <inheritdoc />
         /// </summary>
-        /// <param name="queueName"></param>
-        /// <returns></returns>
         public bool QueueReset(RedisKey queueName)
         {
             bool answ = _db.KeyDelete(queueName);
@@ -343,10 +318,8 @@ namespace EgwCoreLib.Lux.Data.Services.General
         }
 
         /// <summary>
-        /// Reset della coda
+        /// <inheritdoc />
         /// </summary>
-        /// <param name="queueName"></param>
-        /// <returns></returns>
         public async Task<bool> QueueResetAsync(RedisKey queueName)
         {
             bool answ = await _db.KeyDeleteAsync(queueName);
@@ -354,12 +327,8 @@ namespace EgwCoreLib.Lux.Data.Services.General
         }
 
         /// <summary>
-        /// Scrittura string su cache REDIS in modalità Async
+        /// <inheritdoc />
         /// </summary>
-        /// <param name="key"></param>
-        /// <param name="value"></param>
-        /// <param name="tsExpiry"></param>
-        /// <returns></returns>
         public bool Set(string key, string value, TimeSpan? tsExpiry = null)
         {
             Log.Trace($"Set request for {key}");
@@ -367,12 +336,8 @@ namespace EgwCoreLib.Lux.Data.Services.General
         }
 
         /// <summary>
-        /// Scrittura string su cache REDIS in modalità Async
+        /// <inheritdoc />
         /// </summary>
-        /// <param name="key"></param>
-        /// <param name="value"></param>
-        /// <param name="tsExpiry"></param>
-        /// <returns></returns>
         public async Task<bool> SetAsync(string key, string value, TimeSpan? tsExpiry = null)
         {
             Log.Trace($"SetAsync request for {key}");
@@ -380,10 +345,8 @@ namespace EgwCoreLib.Lux.Data.Services.General
         }
 
         /// <summary>
-        /// Sottoscrizione canale REDIS + handler esecuzione
+        /// <inheritdoc />
         /// </summary>
-        /// <param name="channel"></param>
-        /// <param name="handler"></param>
         public void Subscribe(string channel, Action<RedisChannel, RedisValue> handler)
         {
             Log.Trace($"Subscribed to channel {channel}");