mapo-core/MP.INVE/Data/MiDataService.cs

using Egw.Core;
using MP.Data.Conf;
using MP.Data.DatabaseModels;
using Newtonsoft.Json;
using NLog;
using StackExchange.Redis;
using System.Diagnostics;

namespace MP.INVE.Data
{
    public class MiDataService : IDisposable
    {
        #region Public Constructors

        public MiDataService(IConfiguration configuration, ILogger<MiDataService> logger)
        {
            _logger = logger;
            _logger.LogInformation("Starting MiDataService INIT");
            _configuration = configuration;

            // setup compoenti REDIS
            redisConn = ConnectionMultiplexer.Connect(_configuration.GetConnectionString("Redis"));
            redisConnAdmin = ConnectionMultiplexer.Connect(_configuration.GetConnectionString("RedisAdmin"));
            redisDb = redisConn.GetDatabase();

            // leggo cache lungo periodo
            int.TryParse(_configuration.GetValue<string>("ServerConf:redisLongTimeCache"), out redisLongTimeCache);

            _logger.LogInformation("Redis INIT");

            // conf DB
            string connStrData = _configuration.GetConnectionString("Mp.Data");
            string connStrInve = _configuration.GetConnectionString("Mp.Inve");
            if (string.IsNullOrEmpty(connStrData) || string.IsNullOrEmpty(connStrInve))
            {
                _logger.LogError($"DbController: ConnString empty! connStrData: {connStrData} | connStrInve: {connStrInve}");
            }
            else
            {
                dbController = new MP.Data.Controllers.MpInveController(configuration);
                _logger.LogInformation("DbController OK");
            }
        }

        #endregion Public Constructors

        #region Public Properties

        public static MP.Data.Controllers.MpInveController dbController { get; set; } = null!;

        /// <summary>
        /// Dizionario dei tag configurati per IOB
        /// </summary>
        public Dictionary<string, List<TagData>> currTagConf { get; set; } = new Dictionary<string, List<TagData>>();

        #endregion Public Properties

        #region Public Methods

        public string DeriptData(string encData)
        {
            return SteamCrypto.DecryptString(encData, passPhrase);
        }

        public void Dispose()
        {
        }

        public List<AnagOperatoriModel> ElencoOperatori(int matrOpr, string authkey)
        {
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            List<AnagOperatoriModel>? result = new List<AnagOperatoriModel>();
            // cerco in redis...
            RedisValue rawData = redisDb.StringGet(redisElencoOperatori);
            if (!string.IsNullOrEmpty($"{rawData}"))
            {
                var dese = JsonConvert.DeserializeObject<List<AnagOperatoriModel>>($"{rawData}");
                if (dese != null)
                {
                    if ((matrOpr != 0) && (authkey != ""))
                    {
                        result = dese.Where(x => (x.MatrOpr == matrOpr) && (x.authKey == authkey)).ToList();
                    }
                    else
                    {
                        result = dese;
                    }
                }
                stopWatch.Stop();
                TimeSpan ts = stopWatch.Elapsed;
                Log.Debug($"ElencoOperatori Read from REDIS: {ts.TotalMilliseconds}ms");
            }
            else
            {
                result = dbController.ElencoOperatori(matrOpr, authkey);
                // serializzo e salvo...
                rawData = JsonConvert.SerializeObject(result);
                redisDb.StringSetAsync(redisElencoOperatori, rawData, getRandTOut(redisLongTimeCache));
                stopWatch.Stop();
                TimeSpan ts = stopWatch.Elapsed;
                Log.Debug($"ElencoOperatori Read from DB: {ts.TotalMilliseconds}ms");
            }
            if (result == null)
            {
                result = new List<AnagOperatoriModel>();
            }
            return result;
        }

        public string EncriptData(string rawData)
        {
            return SteamCrypto.EncryptString(rawData, passPhrase);
        }

        public List<InventorySessionModel> InventSessCurrList()
        {
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            List<InventorySessionModel> result = new List<InventorySessionModel>();
            string source = "DB";
            // cerco in redis...
            RedisValue rawData = redisDb.StringGet(redisSessionCurrList);
            if (!string.IsNullOrEmpty($"{rawData}"))
            {
                result = JsonConvert.DeserializeObject<List<InventorySessionModel>>($"{rawData}");
                source = "REDIS";
            }
            else
            {
                result = dbController.InventSessCurrList();
                // serializzo e salvo...
                rawData = JsonConvert.SerializeObject(result);
                redisDb.StringSetAsync(redisSessionCurrList, rawData, getRandTOut(redisLongTimeCache));
            }
            stopWatch.Stop();
            TimeSpan ts = stopWatch.Elapsed;
            Log.Debug($"InventSessCurrList Read from {source}: {ts.TotalMilliseconds}ms");
            if (result == null)
            {
                result = new List<InventorySessionModel>();
            }
            return result;
        }

        public List<InventorySessionModel> InventSessHistList(DateTime dtStart, DateTime dtEnd)
        {
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            List<InventorySessionModel> result = new List<InventorySessionModel>();
            string source = "DB";
            // cerco in redis...
            RedisValue rawData = redisDb.StringGet($"{redisSessionHistList}:{dtStart:yyyyMMdd_HHmmss}:{dtEnd:yyyyMMdd_HHmmss}");
            if (!string.IsNullOrEmpty($"{rawData}"))
            {
                result = JsonConvert.DeserializeObject<List<InventorySessionModel>>($"{rawData}");
                source = "REDIS";
            }
            else
            {
                result = dbController.InventSessHistList(dtStart, dtEnd);
                // serializzo e salvo...
                rawData = JsonConvert.SerializeObject(result);
                redisDb.StringSetAsync(redisSessionHistList, rawData, getRandTOut(redisLongTimeCache));
            }
            stopWatch.Stop();
            TimeSpan ts = stopWatch.Elapsed;
            Log.Debug($"InventSessHistList Read from {source}: {ts.TotalMilliseconds}ms");
            if (result == null)
            {
                result = new List<InventorySessionModel>();
            }
            return result;
        }

        #endregion Public Methods

        #region Protected Fields

        protected const string passPhrase = "7871D817-C71F-4DFC-BF12-00A95BE507B5";

        protected Random rand = new Random();

        #endregion Protected Fields

        #region Protected Methods

        /// <summary>
        /// Restituisce un timeout dai minuti richiesti + tempo random 1..60 sec
        /// </summary>
        /// <param name="stdMinutes"></param>
        /// <returns></returns>
        protected TimeSpan getRandTOut(int stdMinutes)
        {
            double rndValue = (double)stdMinutes + (double)rand.Next(1, 60) / 60;
            return TimeSpan.FromMinutes(rndValue);
        }

        #endregion Protected Methods

        #region Private Fields

        private const string redisBaseAddr = "MP:INVE";
        private const string redisElencoOperatori = redisBaseAddr + ":ListOperatori";
        private const string redisSessionCurrList = redisBaseAddr + ":ListSessHist";
        private const string redisSessionHistList = redisBaseAddr + ":ListSessCurr";
        private static IConfiguration _configuration = null!;

        private static ILogger<MiDataService> _logger = null!;

        private static Logger Log = LogManager.GetCurrentClassLogger();

        /// <summary>
        /// Oggetto vocabolario x uso continuo traduzione
        /// </summary>
        private List<VocabolarioModel> ObjVocabolario = new List<VocabolarioModel>();

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

        /// <summary>
        /// Oggetto per connessione a REDIS modalità admin (ex flux dati)
        /// </summary>
        private ConnectionMultiplexer redisConnAdmin = null!;

        /// <summary>
        /// Oggetto DB redis da impiegare x chiamate R/W
        /// </summary>
        private IDatabase redisDb = null!;

        private int redisLongTimeCache = 5;

        #endregion Private Fields
    }
}