webdoorcreator/WebDoorCreator.UI/Data/WDCCurrDataService.cs

using NLog;
using StackExchange.Redis;
using WebDoorCreator.Core;
using WebDoorCreator.Data;

namespace WebDoorCreator.UI.Data
{
    public class WDCCurrDataService : IDisposable
    {
        #region Public Constructors

        public WDCCurrDataService(IConfiguration configuration, IConnectionMultiplexer redisConn)
        {
            _configuration = configuration;

            // setup compoenti REDIS
            this.redisConn = ConnectionMultiplexer.Connect(_configuration.GetConnectionString("Redis"));
            this.redisDb = this.redisConn.GetDatabase();
            // setup canali pub/sub
            calcReqPipe = new MessagePipe(redisConn, Constants.CALC_REQ_QUEUE);
            calcDonePipe = new MessagePipe(redisConn, Constants.CALC_DONE_QUEUE);
        }

        #endregion Public Constructors

        #region Public Properties

        /// <summary>
        /// Message pipe esecuzione elaborazione CAM --&gt; UI
        /// </summary>
        public MessagePipe calcDonePipe { get; set; } = null!;

        /// <summary>
        /// Message pipe richieste elaborazione UI --&gt; CAM
        /// </summary>
        public MessagePipe calcReqPipe { get; set; } = null!;

        #endregion Public Properties

        #region Public Methods

        public void Dispose()
        {
            redisConn.Dispose();
        }

        public async Task<bool> FlushRedisCache()
        {
            await Task.Delay(1);
            RedisValue pattern = new RedisValue($"{Constants.BASE_HASH}:Cache*");
            bool answ = await ExecFlushRedisPattern(pattern);
            return answ;
        }

        public async Task<bool> sendCalcReq(string message)
        {
            // accumulo richieste di calcolo in HashTable redis

            // to do

            // invio sul channel redis la richiesta, salvando il valore anche in cache
            bool answ = calcReqPipe.saveAndSendMessage(Constants.LAST_CALC_REQ_KEY, message);

            // simulazione ritorno dati...
            await Task.Delay(200);

            // invio il FINTO messaggio di ritorno...
            string retMess = "";
            string fileName = Path.Combine("temp", $"Logo{idxSim:00}.svg");
            if (File.Exists(fileName))
            {
                retMess = File.ReadAllText(fileName);
                idxSim++;
                idxSim = idxSim % 4;
            }
            calcDonePipe.saveAndSendMessage(Constants.LAST_CALC_DONE_KEY, retMess);

            return answ;
        }

        #endregion Public Methods

        #region Protected Fields

        protected int idxSim = 0;

        #endregion Protected Fields

        #region Private Fields

        private static IConfiguration _configuration = null!;
        private static Logger Log = LogManager.GetCurrentClassLogger();
#if false
        /// <summary>
        /// Conf allarmi (BankBit) IMPOSTATA con valori silenziati
        /// </summary>
        /// <returns></returns>
        public async Task<List<BaseAlarmBankConf>> getAlarmBankBitSetup()
        {
            List<BaseAlarmBankConf>? redResult = new List<BaseAlarmBankConf>();
            string rawData = await redisDb.StringGetAsync(Constants.ALARMS_SETT_BBIT_KEY);
            //se non avessi trovato valori cerco quelli di setup...
            if (string.IsNullOrEmpty(rawData))
            {
                rawData = await redisDb.StringGetAsync(Constants.ALARMS_CONF_KEY);
            }
            // ora provo a deserializzare
            if (!string.IsNullOrEmpty(rawData))
            {
                redResult = JsonConvert.DeserializeObject<List<BaseAlarmBankConf>>(rawData);
            }
            // altrimenti imposto vuoto
            if (redResult == null)
            {
                redResult = new List<BaseAlarmBankConf>();
            }
            return await Task.FromResult(redResult);
        }
#endif

        /// <summary>
        /// Oggetto per connessione a REDIS
        /// </summary>
        private ConnectionMultiplexer redisConn = null!;

        //ISubscriber sub = redis.GetSubscriber();
        /// <summary>
        /// Oggetto DB redis da impiegare x chiamate R/W
        /// </summary>
        private IDatabase redisDb = null!;

        #endregion Private Fields

        #region Private Methods

        /// <summary>
        /// Esegue flush memoria redis dato pattern
        /// </summary>
        /// <param name="pattern"></param>
        /// <returns></returns>
        private async Task<bool> ExecFlushRedisPattern(RedisValue pattern)
        {
            bool answ = false;
            var listEndpoints = redisConn.GetEndPoints();
            foreach (var endPoint in listEndpoints)
            {
                //var server = redisConnAdmin.GetServer(listEndpoints[0]);
                var server = redisConn.GetServer(endPoint);
                if (server != null)
                {
                    var keyList = server.Keys(redisDb.Database, pattern);
                    foreach (var item in keyList)
                    {
                        await redisDb.KeyDeleteAsync(item);
                    }
                    // brutalmente rimuovo intero contenuto DB... DANGER
                    //await server.FlushDatabaseAsync();
                    answ = true;
                }
            }

            return answ;
        }

        #endregion Private Methods
    }
}