mapo-core/MP.Data/Services/TabDataService.cs

using Microsoft.Extensions.Configuration;
using MP.Data.DatabaseModels;
using MP.Data.DTO;
using Newtonsoft.Json;
using NLog;
using StackExchange.Redis;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Text;
using System.Threading.Tasks;

namespace MP.Data.Services
{
    public class TabDataService : BaseServ, IDisposable
    {
        #region Public Constructors

        public TabDataService(IConfiguration configuration)
        {
            _configuration = configuration;

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

            // conf DB
            string connStr = _configuration.GetConnectionString("Mp.All");
            if (string.IsNullOrEmpty(connStr))
            {
                Log.Error("ConnString empty!");
            }
            else
            {
                StringBuilder sb = new StringBuilder();
                dbTabController = new Controllers.MpTabController(configuration);
                sb.AppendLine($"TabDataService | MpTabController OK");
                dbIocController = new Controllers.MpIocController(configuration);
                sb.AppendLine($"TabDataService | MpIocController OK");
                Log.Info(sb.ToString());
            }
        }

        #endregion Public Constructors

        #region Public Properties

        private static Controllers.MpIocController dbIocController { get; set; } = null!;
        private static Controllers.MpTabController dbTabController { get; set; } = null!;

        #endregion Public Properties

        #region Public Methods

        public async Task<List<AnagEventiModel>> AnagEventiGetAll()
        {
            // setup parametri costanti
            DateTime startDate = new DateTime(2000, 1, 1);
            DateTime endDate = DateTime.Today.AddDays(1);
            string source = "DB";
            Stopwatch sw = new Stopwatch();
            sw.Start();
            List<AnagEventiModel>? result = new List<AnagEventiModel>();
            // cerco in redis...
            string currKey = $"{redisBaseKey}:AnagEventi";
            RedisValue rawData = await redisDb.StringGetAsync(currKey);
            if (!string.IsNullOrEmpty($"{rawData}"))
            {
                result = JsonConvert.DeserializeObject<List<AnagEventiModel>>($"{rawData}");
                source = "REDIS";
            }
            else
            {
                result = dbTabController.AnagEventiGetAll();
                // serializzp e salvo...
                rawData = JsonConvert.SerializeObject(result);
                await redisDb.StringSetAsync(currKey, rawData, LongCache);
            }
            if (result == null)
            {
                result = new List<AnagEventiModel>();
            }
            sw.Stop();
            Log.Debug($"AnagEventiGetAll | {source} | {sw.Elapsed.TotalMilliseconds}ms");
            return result;
        }

        /// <summary>
        /// Effettua conferma prod macchina dell'intero periodo da confermare (ultima conferma
        /// --&gt; dtEvent)
        /// </summary>
        /// <param name="idxMacchina">idx macchina da confermare</param>
        /// <param name="modoConfProd">0=periodo, 1 = giorno, 2 = turno</param>
        /// <param name="numPzConfermati">qta pezzi BUONI da confermare</param>
        /// <param name="numPzScarto">qta pezzi SCARTO da confermare</param>
        /// <param name="DataOraApp">DataOra in cui registrare approvazione</param>
        /// <param name="MatrOpr">Matricola operatore</param>
        /// <returns></returns>
        public bool ConfermaProdMacchina(string idxMacchina, int modoConfProd, int numPzConfermati, int numPzScarto, DateTime DataOraApp, int MatrOpr)
        {
            bool answ = false;
            answ = dbTabController.ConfermaProdMacchina(idxMacchina, modoConfProd, numPzConfermati, numPzScarto, DataOraApp, MatrOpr);
            return answ;
        }

        /// <summary>
        /// Effettua conferma prod macchina dell'intero periodo da confermare (ultima conferma
        /// --&gt; dtEvent)
        /// </summary>
        /// <param name="idxMacchina">idx macchina da confermare</param>
        /// <param name="modoConfProd">0=periodo, 1 = giorno, 2 = turno</param>
        /// <param name="numPzConfermati">qta pezzi BUONI da confermare</param>
        /// <param name="numPzLasciati">
        /// qta pezzi LASCIATI alla macchina da confermare (2 eventi 121 rettifica neg/pos)
        /// </param>
        /// <param name="numPzScarto">qta pezzi SCARTO da confermare</param>
        /// <param name="DataOraApp">DataOra in cui registrare approvazione</param>
        /// <param name="MatrOpr">Matricola operatore</param>
        /// <returns></returns>
        public bool ConfermaProdMacchinaFull(string idxMacchina, int modoConfProd, int numPzConfermati, int numPzLasciati, int numPzScarto, DateTime DataOraApp, int MatrOpr)
        {
            bool answ = false;
            answ = dbTabController.ConfermaProdMacchinaFull(idxMacchina, modoConfProd, numPzConfermati, numPzLasciati, numPzScarto, DataOraApp, MatrOpr);
            return answ;
        }

        /// <summary>
        /// Config values attivi
        /// </summary>
        /// <returns></returns>
        public async Task<List<ConfigModel>> ConfigGetAll()
        {
            string source = "DB";
            Stopwatch sw = new Stopwatch();
            sw.Start();
            List<ConfigModel>? result = new List<ConfigModel>();
            // cerco in redis...
            string currKey = $"{redisBaseKey}:Conf";
            RedisValue rawData = await redisDb.StringGetAsync(currKey);
            if (!string.IsNullOrEmpty($"{rawData}"))
            {
                result = JsonConvert.DeserializeObject<List<ConfigModel>>($"{rawData}");
                source = "REDIS";
            }
            else
            {
                result = await Task.FromResult(dbTabController.ConfigGetAll());
                // serializzp e salvo...
                rawData = JsonConvert.SerializeObject(result);
                await redisDb.StringSetAsync(currKey, rawData, LongCache);
            }
            if (result == null)
            {
                result = new List<ConfigModel>();
            }
            sw.Stop();
            Log.Debug($"ConfigGetAll | {source} | {sw.Elapsed.TotalMilliseconds}ms");
            return result;
        }




        public async Task<IobInfoDTO> IobInfo(string IdxMacchina)
        {
            string source = "DB";
            Stopwatch sw = new Stopwatch();
            sw.Start();
            IobInfoDTO? result = new IobInfoDTO();
            // cerco in redis...
            string currKey = $"{moonProRedisBaseKey}:{IdxMacchina}";
            RedisValue rawData = await redisDb.StringGetAsync(currKey);
            if (!string.IsNullOrEmpty($"{rawData}"))
            {
                result = JsonConvert.DeserializeObject<IobInfoDTO>($"{rawData}");
                source = "REDIS";
            }
            if (result == null)
            {
                result = new IobInfoDTO();
            }
            sw.Stop();
            Log.Debug($"IobInfo | {source} | {sw.Elapsed.TotalMilliseconds}ms");
            return result;
        }

        public void Dispose()
        {
            // Clear database controller
            dbTabController.Dispose();
        }

        /// <summary>
        /// Effettua ricalcolo MSE x macchina indicata
        /// </summary>
        /// <param name="idxMacchina">idx macchina da confermare</param>
        /// <param name="maxAgeSec">Num massimo secondi di "vecchiaia" del dato</param>
        /// <returns></returns>
        public bool RicalcMse(string idxMacchina, int maxAgeSec)
        {
            bool answ = false;
            answ = dbTabController.RicalcMse(idxMacchina, maxAgeSec);
            return answ;
        }

        /// <summary>
        /// Recupero Righe (Actual) della scheda tecnica da GRUPPO + ODL
        /// </summary>
        /// <param name="codGruppo"></param>
        /// <param name="idxODL"></param>
        /// <returns></returns>
        public async Task<List<ST_ActRow>> STAR_byGrpOdl(string codGruppo, int idxODL)
        {
            // setup parametri costanti
            string source = "DB";
            Stopwatch sw = new Stopwatch();
            sw.Start();
            List<ST_ActRow>? result = new List<ST_ActRow>();
            // cerco in redis...
            string currKey = $"{redisBaseKey}:START:{codGruppo}:{idxODL}";
            RedisValue rawData = await redisDb.StringGetAsync(currKey);
            if (!string.IsNullOrEmpty($"{rawData}"))
            {
                result = JsonConvert.DeserializeObject<List<ST_ActRow>>($"{rawData}");
                source = "REDIS";
            }
            else
            {
                result = dbTabController.STAR_byGrpOdl(codGruppo, idxODL);
                // serializzp e salvo...
                rawData = JsonConvert.SerializeObject(result);
                await redisDb.StringSetAsync(currKey, rawData, LongCache);
            }
            if (result == null)
            {
                result = new List<ST_ActRow>();
            }
            sw.Stop();
            Log.Debug($"STAR_byGrpOdl | {source} | {sw.Elapsed.TotalMilliseconds}ms");
            return result;
        }

        /// <summary>
        /// Recupero Righe (Actual) della scheda tecnica da GRUPPO + ODL
        /// </summary>
        /// <param name="codGruppo"></param>
        /// <param name="label"></param>
        /// <param name="idxODL"></param>
        /// <returns></returns>
        public async Task<List<ST_ActRow>> STAR_byGrpOdlLbl(string codGruppo, string label, int idxODL)
        {
            // setup parametri costanti
            string source = "DB";
            Stopwatch sw = new Stopwatch();
            sw.Start();
            List<ST_ActRow>? result = new List<ST_ActRow>();
            // cerco in redis...
            string currKey = $"{redisBaseKey}:START:{codGruppo}:{label}:{idxODL}";
            RedisValue rawData = await redisDb.StringGetAsync(currKey);
            if (!string.IsNullOrEmpty($"{rawData}"))
            {
                result = JsonConvert.DeserializeObject<List<ST_ActRow>>($"{rawData}");
                source = "REDIS";
            }
            else
            {
                result = dbTabController.STAR_byGrpOdlLbl(codGruppo, label, idxODL);
                // serializzp e salvo...
                rawData = JsonConvert.SerializeObject(result);
                await redisDb.StringSetAsync(currKey, rawData, LongCache);
            }
            if (result == null)
            {
                result = new List<ST_ActRow>();
            }
            sw.Stop();
            Log.Debug($"STAR_byGrpOdlLbl | {source} | {sw.Elapsed.TotalMilliseconds}ms");
            return result;
        }

        /// <summary>
        /// Stato prod macchina (completo)
        /// </summary>
        /// <param name="idxMacchina"></param>
        /// <param name="dtReq"></param>
        /// <returns></returns>
        public async Task<StatoProdModel> StatoProdMacchina(string idxMacchina, DateTime dtReq)
        {
            // setup parametri costanti
            string source = "DB";
            Stopwatch sw = new Stopwatch();
            sw.Start();
            StatoProdModel? result = new StatoProdModel();
            // cerco in redis...
            string currKey = $"{redisBaseKey}:StatoProd:{idxMacchina}:{dtReq:HHmmss}";
            RedisValue rawData = await redisDb.StringGetAsync(currKey);
            if (!string.IsNullOrEmpty($"{rawData}"))
            {
                result = JsonConvert.DeserializeObject<StatoProdModel>($"{rawData}");
                source = "REDIS";
            }
            else
            {
                result = dbTabController.StatoProdMacchina(idxMacchina, dtReq);
                // serializzp e salvo...
                rawData = JsonConvert.SerializeObject(result);
                await redisDb.StringSetAsync(currKey, rawData, UltraFastCache);
            }
            if (result == null)
            {
                result = new StatoProdModel();
            }
            sw.Stop();
            Log.Debug($"StatoProdMacchina | {source} | {sw.Elapsed.TotalMilliseconds}ms");
            return result;
        }

        /// <summary>
        /// Intera vista v_MSFD
        /// </summary>
        /// <returns></returns>
        public async Task<List<VMSFDModel>> VMSFDGetAll()
        {
            // setup parametri costanti
            string source = "DB";
            Stopwatch sw = new Stopwatch();
            sw.Start();
            List<VMSFDModel> result = new List<VMSFDModel>();
            // cerco in redis...
            string currKey = $"{redisBaseKey}:MSFD:ALL";
            RedisValue rawData = await redisDb.StringGetAsync(currKey);
            if (!string.IsNullOrEmpty($"{rawData}"))
            {
                result = JsonConvert.DeserializeObject<List<VMSFDModel>>($"{rawData}");
                source = "REDIS";
            }
            else
            {
                result = dbIocController.VMSFDGetAll();
                // serializzp e salvo...
                rawData = JsonConvert.SerializeObject(result);
                await redisDb.StringSetAsync(currKey, rawData, UltraLongCache);
            }
            if (result == null)
            {
                result = new List<VMSFDModel>();
            }
            sw.Stop();
            Log.Debug($"VMSFDGetAll | {source} | {sw.Elapsed.TotalMilliseconds}ms");
            return result;
        }

        /// <summary>
        /// Vista v_MSFD x singola macchina (da stored) - singolo record
        /// </summary>
        /// <param name="idxMacc"></param>
        /// <returns></returns>
        public async Task<List<VMSFDModel>> VMSFDGetByMacc(string idxMacc)
        {
            // setup parametri costanti
            string source = "DB";
            Stopwatch sw = new Stopwatch();
            sw.Start();
            List<VMSFDModel>? result = new List<VMSFDModel>();
            // cerco in redis...
            string currKey = $"{redisBaseKey}:MSFD:MACCH:{idxMacc}";
            RedisValue rawData = await redisDb.StringGetAsync(currKey);
            if (!string.IsNullOrEmpty($"{rawData}"))
            {
                result = JsonConvert.DeserializeObject<List<VMSFDModel>>($"{rawData}");
                source = "REDIS";
            }
            else
            {
                result = dbIocController.VMSFDGetByMacc(idxMacc);
                // serializzp e salvo...
                rawData = JsonConvert.SerializeObject(result);
                await redisDb.StringSetAsync(currKey, rawData, UltraFastCache);
            }
            if (result == null)
            {
                result = new List<VMSFDModel>();
            }
            sw.Stop();
            Log.Debug($"VMSFDGetByMacc | {source} | {sw.Elapsed.TotalMilliseconds}ms");
            return result;
        }
        /// <summary>
        /// Vista v_MSFD delle machine MULTI filtrato x macchina (da stored)
        /// </summary>
        /// <param name="idxMacc"></param>
        /// <returns></returns>
        public async Task<List<VMSFDModel>> VMSFDGetMultiByMacc(string idxMacc)
        {
            // setup parametri costanti
            string source = "DB";
            Stopwatch sw = new Stopwatch();
            sw.Start();
            List<VMSFDModel>? result = new List<VMSFDModel>();
            // cerco in redis...
            string currKey = $"{redisBaseKey}:MSFD:MULTI:{idxMacc}";
            RedisValue rawData = await redisDb.StringGetAsync(currKey);
            if (!string.IsNullOrEmpty($"{rawData}"))
            {
                result = JsonConvert.DeserializeObject<List<VMSFDModel>>($"{rawData}");
                source = "REDIS";
            }
            else
            {
                result = dbIocController.VMSFDGetByMacc(idxMacc);
                // serializzp e salvo...
                rawData = JsonConvert.SerializeObject(result);
                await redisDb.StringSetAsync(currKey, rawData, UltraLongCache);
            }
            if (result == null)
            {
                result = new List<VMSFDModel>();
            }
            sw.Stop();
            Log.Debug($"VMSFDGetMultiByMacc | {source} | {sw.Elapsed.TotalMilliseconds}ms");
            return result;
        }

        #endregion Public Methods

        #region Protected Fields

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

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

        #endregion Protected Fields

        #region Private Fields

        private static Logger Log = LogManager.GetCurrentClassLogger();
        private string redisBaseKey = "MP:TAB:Cache";
        private string moonProRedisBaseKey = "MoonPro:SQL2016DEV:MoonPro:hM2IOB";

        #endregion Private Fields
    }
}