lux/EgwCoreLib.Lux.Data/Services/General/IRedisService.cs

namespace EgwCoreLib.Lux.Data.Services.General
{
    /// <summary>
    /// Interfaccia servizio REDIS x pub/sub e caching
    /// </summary>
    public interface IRedisService
    {
        #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
    }
}