using EgwCoreLib.Utils;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
using MP.Core.DTO;
using MP.Core.Objects;
using MP.Data.DbModels;
using Newtonsoft.Json;
using NLog;
using StackExchange.Redis;
using System;
using System.Collections.Generic;
using System.Data;
using System.Diagnostics;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

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

        /// <summary>
        /// Init servizio TAB
        /// </summary>
        /// <param name="configuration"></param>
        public TabDataService(IConfiguration configuration, IConnectionMultiplexer redConn) : base(configuration, redConn)
        {
            _configuration = configuration;

            // conf DB
            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");
                dbInveController = new Controllers.MpInveController(configuration);
                sb.AppendLine($"TabDataService | MpInveController OK");
                Log.Info(sb.ToString());
                // sistemo i parametri x redHas...
                CodModulo = _configuration.GetValue<string>("SpecialConf:CodModulo");
                CodModuloParam = _configuration.GetValue<string>("SpecialConf:CodModuloParam");
#if false
                MpIoNS = _configuration.GetValue<string>("ServerConf:MpIoNS");
#endif
                var cstringArray = ConnStr.Split(";");
                foreach (var item in cstringArray)
                {
                    var cData = item.Trim().Split("=");
                    if (cData.Length == 2)
                    {
                        if (!connStrParams.ContainsKey(cData[0]))
                        {
                            connStrParams.Add(cData[0], cData[1]);
                        }
                    }
                }
                // sistemo
                DataSource = connStrParams["Server"];
                DataBase = connStrParams["Database"];
            }
        }

        #endregion Public Constructors

        #region Public Events

        /// <summary>
        /// Evento report dati invalidati x rilettura
        /// </summary>
        public event EventHandler DataInvalidated = delegate { };

        /// <summary>
        /// Evento richiesta rilettura dati pagina (x refresh pagine aperte)
        /// </summary>
        public event EventHandler ReloadRequest = delegate { };

        #endregion Public Events

        #region Public Properties

        /// <summary>
        /// Conmfig attivo da DB
        /// </summary>
        public List<ConfigModel> CurrConfig { get; set; } = new List<ConfigModel>();

        #endregion Public Properties

        #region Public Methods

        /// <summary>
        /// Aggiunge un task all'elenco di quelli salvati (in modalità upsert)
        /// </summary>
        /// <param name="idxMacchina"></param>
        /// <param name="taskKey"></param>
        /// <param name="taskVal"></param>
        /// <returns></returns>
        public bool addTask4Machine(string idxMacchina, Enums.taskType taskKey, string taskVal)
        {
            bool answ = false;
            string currHash = exeTaskHash(idxMacchina);
            string currSavedParHash = savedTaskHash(idxMacchina);
            Dictionary<string, string> currTask = new Dictionary<string, string>();
            Dictionary<string, string> savedTask = new Dictionary<string, string>();
            try
            {
                //Log.Info($"Request: idxMacchina: {idxMacchina} | taskKey: {taskKey} | taskVal: {taskVal}");
                // leggo task attuali...
                currTask = mTaskMacchina(idxMacchina);
                if (currTask.ContainsKey($"{taskKey}"))
                {
                    currTask[$"{taskKey}"] = taskVal;
                }
                else
                {
                    currTask.Add($"{taskKey}", taskVal);
                }
                answ = redisHashDictSet(currHash, currTask);
                Log.Info($"Task ADD | hash: {currHash} | - idxMacchina: {idxMacchina} | taskKey: {taskKey} | taskVal: {taskVal}");
            }
            catch { }
            // verifico in base al tipo di task se fare backup...
            switch (taskKey)
            {
                case Enums.taskType.setArt:
                case Enums.taskType.setComm:
                case Enums.taskType.setPzComm:
                case Enums.taskType.setProg:
                    // leggo task SALVATI attuali...
                    savedTask = mSavedTaskMacchina(idxMacchina);
                    savedTask[taskKey.ToString()] = taskVal;
                    answ = redisHashDictSet(currSavedParHash, savedTask);
                    break;

                case Enums.taskType.endProd:
                    // salvo un DICT vuoto x resettare
                    savedTask = new Dictionary<string, string>();
                    answ = redisHashDictSet(currSavedParHash, savedTask);
                    break;

                default:
                    break;
            }
            return answ;
        }

        /// <summary>
        /// Elenco allarmi macchina
        /// </summary>
        /// <param name="idxMacchina">Macchina</param>
        /// <param name="dtFrom">Inizio periodo</param>
        /// <param name="dtTo">Fine periodo</param>
        /// <param name="showMulti"></param>
        /// <returns></returns>
        public async Task<List<AlarmLogModel>> AlarmLogListFilt(string idxMacchina, DateTime dtFrom, DateTime dtTo, bool showMulti)
        {
            string source = "DB";
            Stopwatch sw = new Stopwatch();
            sw.Start();
            List<AlarmLogModel>? result = new List<AlarmLogModel>();
            // cerco in _redisConn...
            string currKey = $"{redisBaseKey}:AlarmLog:{idxMacchina}:{dtFrom:yyyyMMdd-HHmmss}:{dtTo::yyyyMMdd-HHmmss}:{showMulti}";
            RedisValue rawData = await _redisDb.StringGetAsync(currKey);
            if (rawData.HasValue)
            {
                result = JsonConvert.DeserializeObject<List<AlarmLogModel>>($"{rawData}");
                source = "REDIS";
            }
            else
            {
                result = await Task.FromResult(dbTabController.AlarmLogListFilt(idxMacchina, dtFrom, dtTo, showMulti));
                // serializzo e salvo...
                rawData = JsonConvert.SerializeObject(result);
                await _redisDb.StringSetAsync(currKey, rawData, UltraFastCache);
            }
            if (result == null)
            {
                result = new List<AlarmLogModel>();
            }
            sw.Stop();
            Log.Debug($"AlarmLogListFilt | {source} | {sw.Elapsed.TotalMilliseconds}ms");
            return result;
        }

        /// <summary>
        /// Registrato ACK allarme
        /// </summary>
        /// <param name="alarmLogId">Id Allarme</param>
        /// <param name="dtAck">Data Ack</param>
        /// <param name="userAck">User Ack</param>
        /// <returns></returns>
        public bool AlarmLogSetAck(int alarmLogId, DateTime dtAck, string userAck)
        {
            bool answ = dbTabController.AlarmLogSetAck(alarmLogId, dtAck, userAck);
            return answ;
        }

        /// <summary>
        /// Registrato ACK allarme
        /// </summary>
        /// <param name="alarmLogId">Id Allarme</param>
        /// <param name="dtNotify">Data Ack</param>
        /// <returns></returns>
        public bool AlarmLogSetNotify(int alarmLogId, DateTime dtNotify)
        {
            bool answ = dbTabController.AlarmLogSetNotify(alarmLogId, dtNotify);
            return answ;
        }

        /// <summary>
        /// Elenco completo EVENTI
        /// </summary>
        /// <returns></returns>
        public async Task<List<AnagEventiModel>> AnagEventiGetAll()
        {
            // setup parametri costanti
            string source = "DB";
            Stopwatch sw = new Stopwatch();
            sw.Start();
            List<AnagEventiModel>? result = new List<AnagEventiModel>();
            // cerco in _redisConn...
            string currKey = $"{redisBaseKey}:AnagEventi:ALL";
            RedisValue rawData = await _redisDb.StringGetAsync(currKey);
            if (rawData.HasValue)
            {
                result = JsonConvert.DeserializeObject<List<AnagEventiModel>>($"{rawData}");
                source = "REDIS";
            }
            else
            {
                result = dbTabController.AnagEventiGetAll();
                // serializzo 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>
        /// Elenco EVENTI validi x macchina
        /// </summary>
        /// <returns></returns>
        public List<vSelEventiBCodeModel> AnagEventiGetByMacch(string IdxMacch)
        {
            string source = "DB";
            Stopwatch sw = new Stopwatch();
            sw.Start();
            List<vSelEventiBCodeModel>? result = new List<vSelEventiBCodeModel>();
            // cerco in _redisConn...
            string currKey = $"{redisBaseKey}:VSEB:{IdxMacch}";
            RedisValue rawData = _redisDb.StringGet(currKey);
            if (rawData.HasValue)
            {
                result = JsonConvert.DeserializeObject<List<vSelEventiBCodeModel>>($"{rawData}");
                source = "REDIS";
            }
            else
            {
                result = dbTabController.AnagEventiGetByMacc(IdxMacch);
                // serializzo e salvo...
                rawData = JsonConvert.SerializeObject(result);
                _redisDb.StringSet(currKey, rawData, LongCache);
            }
            if (result == null)
            {
                result = new List<vSelEventiBCodeModel>();
            }
            sw.Stop();
            Log.Debug($"AnagEventiGetByMacch | {source} | {sw.Elapsed.TotalMilliseconds}ms");
            return result;
        }

        /// <summary>
        /// Restituisce l'anagrafica EVENTI per intero
        /// </summary>
        /// <returns></returns>
        public async Task<List<AnagTagsModel>> AnagTagsOrd()
        {
            // setup parametri costanti
            string source = "DB";
            Stopwatch sw = new Stopwatch();
            sw.Start();
            List<AnagTagsModel>? result = new List<AnagTagsModel>();
            // cerco in _redisConn...
            string currKey = $"{redisBaseKey}:AnagTags";
            RedisValue rawData = await _redisDb.StringGetAsync(currKey);
            if (rawData.HasValue)
            {
                result = JsonConvert.DeserializeObject<List<AnagTagsModel>>($"{rawData}");
                source = "REDIS";
            }
            else
            {
                result = dbTabController.AnagTagsOrd();
                // serializzo e salvo...
                rawData = JsonConvert.SerializeObject(result);
                await _redisDb.StringSetAsync(currKey, rawData, UltraLongCache);
            }
            if (result == null)
            {
                result = new List<AnagTagsModel>();
            }
            sw.Stop();
            Log.Debug($"AnagTagsOrd | {source} | {sw.Elapsed.TotalMilliseconds}ms");
            return result;
        }

        /// <summary>
        /// Elenco completo STATI
        /// </summary>
        /// <returns></returns>
        public async Task<List<AnagStatiModel>> AnaStatiGetAll()
        {
            // 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<AnagStatiModel>? result = new List<AnagStatiModel>();
            // cerco in _redisConn...
            string currKey = $"{redisBaseKey}:AnagStati";
            RedisValue rawData = await _redisDb.StringGetAsync(currKey);
            //if (!string.IsNullOrEmpty($"{rawData}"))
            if (rawData.HasValue)
            {
                result = JsonConvert.DeserializeObject<List<AnagStatiModel>>($"{rawData}");
                source = "REDIS";
            }
            else
            {
                result = dbTabController.AnagStatiGetAll();
                // serializzo e salvo...
                rawData = JsonConvert.SerializeObject(result);
                await _redisDb.StringSetAsync(currKey, rawData, LongCache);
            }
            if (result == null)
            {
                result = new List<AnagStatiModel>();
            }
            sw.Stop();
            Log.Debug($"AnaStatiGetAll | {source} | {sw.Elapsed.TotalMilliseconds}ms");
            return result;
        }

        /// <summary>
        /// Restitusice elenco articoli dato tipo (es KIT)
        /// </summary>
        /// <param name="tipo"></param>
        /// <param name="azienda"></param>
        /// <returns></returns>
        public List<AnagArticoliModel> ArticoliGetByTipo(string tipo, string azienda = "*")
        {
            List<AnagArticoliModel>? result = new List<AnagArticoliModel>();
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            string readType = "DB";
            string sKey = string.IsNullOrEmpty(tipo) ? "ALL" : tipo;
            string currKey = $"{MP.Core.Utils.redisArtList}:{azienda}:Tipo:{sKey}";
            // cerco in _redisConn dato valore sel idxMaccSel...
            RedisValue rawData = _redisDb.StringGet(currKey);
            if (rawData.HasValue)
            {
                result = JsonConvert.DeserializeObject<List<AnagArticoliModel>>($"{rawData}");
                readType = "REDIS";
            }
            else
            {
                result = dbTabController.ArticoliGetByTipo(tipo, azienda);
                // serializzo e salvo...
                rawData = JsonConvert.SerializeObject(result);
                _redisDb.StringSet(currKey, rawData, UltraLongCache);
            }
            if (result == null)
            {
                result = new List<AnagArticoliModel>();
            }
            stopWatch.Stop();
            TimeSpan ts = stopWatch.Elapsed;
            Log.Debug($"ArticoliGetByTipo | Read from {readType}: {ts.TotalMilliseconds}ms");
            return result;
        }

        /// <summary>
        /// Recupera elenco ultimi commenti
        /// </summary>
        /// <param name="idxMacchina">Idx macchina, "*" = tutte</param>
        /// <param name="numDays">Num di giorni da recuperare da adesso</param>
        /// <returns></returns>
        public async Task<List<CommentiModel>> CommentiGetLastByMacc(string idxMacchina, int numDays)
        {
            // setup parametri costanti
            string source = "DB";
            Stopwatch sw = new Stopwatch();
            sw.Start();
            List<CommentiModel> result = new List<CommentiModel>();
            DateTime adesso = DateTime.Now;
            // cerco in _redisConn...
            string currKey = $"{redisBaseKey}:Commenti:{idxMacchina}:{adesso:yyMMdd-HHmm}:{numDays}";
            RedisValue rawData = await _redisDb.StringGetAsync(currKey);
            //if (!string.IsNullOrEmpty($"{rawData}"))
            if (rawData.HasValue)
            {
                result = JsonConvert.DeserializeObject<List<CommentiModel>>($"{rawData}");
                source = "REDIS";
            }
            else
            {
                result = dbTabController.CommentiGetLastByMacc(idxMacchina, numDays);
                // serializzo e salvo...
                rawData = JsonConvert.SerializeObject(result);
                await _redisDb.StringSetAsync(currKey, rawData, UltraFastCache);
            }
            if (result == null)
            {
                result = new List<CommentiModel>();
            }
            sw.Stop();
            Log.Debug($"CommentiGetLastByMacc | {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 List<ConfigModel> ConfigGetAll()
        {
            string source = "DB";
            Stopwatch sw = new Stopwatch();
            sw.Start();
            List<ConfigModel>? result = new List<ConfigModel>();
            // cerco in _redisConn...
            string currKey = $"{redisBaseKey}:Conf";
            RedisValue rawData = _redisDb.StringGet(currKey);
            //if (!string.IsNullOrEmpty($"{rawData}"))
            if (rawData.HasValue)
            {
                result = JsonConvert.DeserializeObject<List<ConfigModel>>($"{rawData}");
                source = "REDIS";
            }
            else
            {
                result = dbTabController.ConfigGetAll();
                // serializzo e salvo...
                rawData = JsonConvert.SerializeObject(result);
                _redisDb.StringSet(currKey, rawData, LongCache);
            }
            if (result == null)
            {
                result = new List<ConfigModel>();
            }
            sw.Stop();
            Log.Debug($"ConfigGetAll | {source} | {sw.Elapsed.TotalMilliseconds}ms");
            return result;
        }

        /// <summary>
        /// Recupera il valore in formato STRING
        /// </summary>
        /// <param name="chiave">Valore da cercare</param>
        /// <param name="varObj">String in cui salvare il valore se trovato</param>
        /// <returns></returns>
        public bool ConfigGetVal(string chiave, ref string varObj)
        {
            bool answ = false;
            // se mancasse provo a configurare..
            if (CurrConfig == null || CurrConfig.Count == 0)
            {
                SetupConfig();
            }
            if (CurrConfig != null && CurrConfig.Count > 0)
            {
                // sistemo i parametri opzionali...
                ConfigModel? risultato = CurrConfig.FirstOrDefault(x => x.Chiave == chiave);
                if (risultato != null)
                {
                    varObj = risultato.Valore;
                    answ = !string.IsNullOrEmpty(risultato.Valore);
                }
            }
            return answ;
        }

        /// <summary>
        /// Recupera il valore in formato INT
        /// </summary>
        /// <param name="chiave">Valore da cercare</param>
        /// <param name="varObj">Int in cui salvare il valore se trovato</param>
        /// <returns></returns>
        public bool ConfigGetVal(string chiave, ref int varObj)
        {
            bool answ = false;
            // se mancasse provo a configurare..
            if (CurrConfig == null || CurrConfig.Count == 0)
            {
                SetupConfig();
            }
            if (CurrConfig != null && CurrConfig.Count > 0)
            {
                // sistemo i parametri opzionali...
                ConfigModel? risultato = CurrConfig.FirstOrDefault(x => x.Chiave == chiave);
                if (risultato != null)
                {
                    answ = int.TryParse(risultato.Valore, out varObj);
                }
            }
            return answ;
        }

        /// <summary>
        /// Recupera il valore in formato DOUBLE
        /// </summary>
        /// <param name="chiave">Valore da cercare</param>
        /// <param name="varObj">Int in cui salvare il valore se trovato</param>
        /// <returns></returns>
        public bool ConfigGetVal(string chiave, ref double varObj)
        {
            bool answ = false;
            // se mancasse provo a configurare..
            if (CurrConfig == null || CurrConfig.Count == 0)
            {
                SetupConfig();
            }
            if (CurrConfig != null && CurrConfig.Count > 0)
            {
                // sistemo i parametri opzionali...
                ConfigModel? risultato = CurrConfig.FirstOrDefault(x => x.Chiave == chiave);
                if (risultato != null)
                {
                    NumberStyles numStyle;
                    CultureInfo culture;
                    numStyle = NumberStyles.Number;
                    culture = CultureInfo.InvariantCulture;
                    //culture = CultureInfo.CreateSpecificCulture("en-US");
                    answ = double.TryParse(risultato.Valore, numStyle, culture, out varObj);
                }
            }
            return answ;
        }

        /// <summary>
        /// Recupera il valore in formato BOOL
        /// </summary>
        /// <param name="chiave">Valore da cercare</param>
        /// <param name="varObj">Boolean in cui salvare il valore se trovato</param>
        /// <returns></returns>
        public bool ConfigGetVal(string chiave, ref bool varObj)
        {
            bool answ = false;
            // se mancasse provo a configurare..
            if (CurrConfig == null || CurrConfig.Count == 0)
            {
                SetupConfig();
            }
            if (CurrConfig != null && CurrConfig.Count > 0)
            {
                // sistemo i parametri opzionali...
                ConfigModel? risultato = CurrConfig.FirstOrDefault(x => x.Chiave == chiave);
                if (risultato != null)
                {
                    answ = bool.TryParse(risultato.Valore, out varObj);
                }
            }
            return answ;
        }

        /// <summary>
        /// Inserimento record in DDB
        /// </summary>
        /// <param name="idxMacchina"></param>
        /// <param name="inizio"></param>
        /// <param name="idxStatoStart"></param>
        /// <param name="nStepEventi"></param>
        /// <param name="nRecCheck"></param>
        /// <param name="checkOnly"></param>
        /// <returns></returns>
        public async Task<bool> DDB_DoRecalc(string idxMacchina, DateTime inizio, int idxStatoStart, int nStepEventi, int nRecCheck, bool checkOnly)
        {
            bool answ = dbTabController.DDB_DoRecalc(idxMacchina, inizio, idxStatoStart, nStepEventi, nRecCheck, checkOnly);
            await FlushCache();
            return answ;
        }

        /// <summary>
        /// Recupera record successivo da DDB
        /// </summary>
        /// <param name="idxMacchina"></param>
        /// <param name="inizioStato"></param>
        /// <returns></returns>
        public DiarioDiBordoModel DDB_getNext(string idxMacchina, DateTime inizioStato)
        {
            return dbTabController.DDB_getNext(idxMacchina, inizioStato);
        }

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

        /// <summary>
        /// Restituisce elenco ElencoConfermeProd filtrato e async
        /// </summary>
        /// <param name="idxMacchina"></param>
        /// <param name="dataFrom"></param>
        /// <param name="dataTo"></param>
        /// <returns></returns>
        public async Task<List<ElencoConfermeProdModel>> ElencoConfProdFiltAsync(string idxMacchina, DateTime dataFrom, DateTime dataTo)
        {
            // setup parametri costanti
            string source = "DB";
            Stopwatch sw = new Stopwatch();
            sw.Start();
            List<ElencoConfermeProdModel> result = new List<ElencoConfermeProdModel>();
            // cerco in _redisConn...
            string currKey = $"{redisBaseKey}:ElConfProd:{idxMacchina}:{dataFrom:yyyyyMMdd-HHmm}:{dataFrom:yyyyyMMdd-HHmm}";
            RedisValue rawData = await _redisDb.StringGetAsync(currKey);
            if (rawData.HasValue)
            {
                result = JsonConvert.DeserializeObject<List<ElencoConfermeProdModel>>($"{rawData}") ?? new List<ElencoConfermeProdModel>();
                source = "REDIS";
            }
            else
            {
                result = dbTabController.ElencoConfProdFilt(idxMacchina, dataFrom, dataTo);
                // serializzo e salvo...
                rawData = JsonConvert.SerializeObject(result);
                await _redisDb.StringSetAsync(currKey, rawData, UltraLongCache);
            }
            sw.Stop();
            string callName = $"ElencoConfProdFiltAsync.{source}";
            int numRec = esCollect.RecordCall(callName, sw.Elapsed.TotalMilliseconds);
            if (numRec >= nRecLog)
            {
                Log.Debug(esCollect.GetCallSum(callName, true));
            }
            return result;
        }

        /// <summary>
        /// Fix ODL per Elenco Lotti
        /// </summary>
        /// <param name="idxOdl"></param>
        /// <param name="flgStorico"></param>
        /// <returns></returns>
        public async Task<bool> ElencoLottiUpsertByOdl(int idxOdl, bool flgStorico)
        {
            bool answ = false;
            try
            {
                // inserisco evento
                answ = dbTabController.ElencoLottiUpsertByOdl(idxOdl, flgStorico);
                await FlushCache("EL");
            }
            catch (Exception exc)
            {
                string logMsg = $"Eccezione in ElencoLottiUpsertByOdl | idxOdl: {idxOdl} | flgStorico: {flgStorico}{Environment.NewLine}{exc}";
                Log.Error(logMsg);
            }
            return answ;
        }

        /// <summary>
        /// Elenco operatori
        /// </summary>
        /// <returns></returns>
        public async Task<List<AnagOperatoriModel>> ElencoOperatori()
        {
            string source = "DB";
            Stopwatch sw = new Stopwatch();
            sw.Start();
            List<AnagOperatoriModel>? result = new List<AnagOperatoriModel>();
            // cerco in _redisConn...
            string currKey = $"{redisBaseKey}:ElencoOpr";
            RedisValue rawData = await _redisDb.StringGetAsync(currKey);
            if (rawData.HasValue)
            {
                result = JsonConvert.DeserializeObject<List<AnagOperatoriModel>>($"{rawData}");
                source = "REDIS";
            }
            else
            {
                result = dbTabController.ElencoOperatori();
                // serializzo e salvo...
                rawData = JsonConvert.SerializeObject(result);
                await _redisDb.StringSetAsync(currKey, rawData, LongCache);
            }
            if (result == null)
            {
                result = new List<AnagOperatoriModel>();
            }
            sw.Stop();
            Log.Debug($"ElencoOperatori | {source} | {sw.Elapsed.TotalMilliseconds}ms");
            return result;
        }

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

        /// <summary>
        /// Elimina una riga in EventList se trovata
        /// </summary>
        /// <param name="idxMacchina"></param>
        /// <param name="dtEvento"></param>
        /// <param name="idxTipo"></param>
        /// <returns></returns>
        public async Task<bool> EvListDelete(string idxMacchina, DateTime dtEvento, int idxTipo)
        {
            bool fatto = false;
            try
            {
                // inserisco evento
                fatto = dbTabController.EvListDelete(idxMacchina, dtEvento, idxTipo);
                // reset cache eventi/commenti
                await FlushCache("EvList");
                await FlushCache("Commenti");
            }
            catch (Exception exc)
            {
                string logMsg = $"Eccezione in EvListDelete | macchina: {idxMacchina} | DataEv: {dtEvento} | idxTipo: {idxTipo}{Environment.NewLine}{exc}";
                Log.Error(logMsg);
            }
            return fatto;
        }

        /// <summary>
        /// Recupera record EventList date condizioni filtro
        /// </summary>
        /// <param name="idxMacchina">Idx macchina, "*" = tutte</param>
        /// <param name="dtLimit">Data limite per recupero antecedenti</param>
        /// <param name="idxTipo">Tipo evento cercato, 0 = tutti</param>
        /// <param name="maxRec">Num massimo di record da recuperare</param>
        /// <returns></returns>
        public async Task<List<EventListModel>> EvListGetLastBySearch(string idxMacchina, DateTime dtLimit, int idxTipo, int maxRec)
        {
            // setup parametri costanti
            string source = "DB";
            Stopwatch sw = new Stopwatch();
            sw.Start();
            List<EventListModel> result = new List<EventListModel>();
            // cerco in _redisConn...
            string currKey = $"{redisBaseKey}:EvList:Last:{idxMacchina}:{idxTipo}:{dtLimit:yyyyMMdd-HHmm}:{maxRec}";
            RedisValue rawData = await _redisDb.StringGetAsync(currKey);
            //if (!string.IsNullOrEmpty($"{rawData}"))
            if (rawData.HasValue)
            {
                result = JsonConvert.DeserializeObject<List<EventListModel>>($"{rawData}");
                source = "REDIS";
            }
            else
            {
                result = await dbTabController.EvListGetLastBySearch(idxMacchina, dtLimit, idxTipo, maxRec);
                // serializzo e salvo...
                rawData = JsonConvert.SerializeObject(result);
                await _redisDb.StringSetAsync(currKey, rawData, LongCache);
            }
            if (result == null)
            {
                result = new List<EventListModel>();
            }
            sw.Stop();
            Log.Debug($"EvListGetLastBySearch | {source} | {sw.Elapsed.TotalMilliseconds}ms");
            return result;
        }

        /// <summary>
        /// Scrive una riga in EventList inviato nel db + check
        /// </summary>
        /// <param name="newRec">Record da registrare</param>
        /// <returns></returns>
        public async Task<inputComandoMapo> EvListInsert(EventListModel newRec, Enums.tipoInputEvento tipoEv)
        {
            bool inserito = false;
            try
            {
                // inserisco evento
                inserito = await dbTabController.EvListInsert(newRec);
                // reset cache eventi/commenti
                await FlushCache("EvList");
                await FlushCache("Commenti");
            }
            catch (Exception exc)
            {
                string logMsg = $"Eccezione in fase di scrittura evento con i seguenti dati | macchina: {newRec.IdxMacchina} | IdxTipo: {newRec.IdxTipo} | CodArticolo: {newRec.CodArticolo} | Value {newRec.Value} | MatrOpr {newRec.MatrOpr} | Pallet {newRec.pallet}{Environment.NewLine}{exc}";
                Log.Error(logMsg);
            }
            // se non è un commento...
            if (tipoEv != Enums.tipoInputEvento.commento)
            {
                try
                {
                    // faccio controllo per eventuale cambio stato da tab transizioni...
                    dbTabController.CheckCambiaStatoBatch(tipoEv, newRec.IdxMacchina, newRec.InizioStato ?? DateTime.Now, newRec.IdxTipo, newRec.CodArticolo, newRec.Value, newRec.MatrOpr, newRec.pallet);
                }
                catch (Exception exc)
                {
                    string logMsg = $"Eccezione in checkCambiaStatoBatch(6) | tipoInputEvento: {tipoEv} |macchina: {newRec.IdxMacchina} | IdxTipo: {newRec.IdxTipo} | CodArticolo: {newRec.CodArticolo} | Value: {newRec.Value} | MatrOpr: {newRec.MatrOpr} | Pallet: {newRec.pallet}{Environment.NewLine}{exc}";
                    Log.Error(logMsg);
                }
            }
            // formatto output
            inputComandoMapo answ = new inputComandoMapo();
            answ.outValue = inserito.ToString();
            answ.needStatusRefresh = true;
            return answ;
        }

        /// <summary>
        /// Recupera elenco fermi non qualificati da filtro
        /// </summary>
        /// <param name="idxMacchina">Idx macchina, "*" = tutte</param>
        /// <param name="gg">Num massimo di giorni antecedenti</param>
        /// <param name="durataMin">Durata minima (in minuti)</param>
        /// <returns></returns>
        public async Task<List<FermiNonQualModel>> FermiNonQualificatiFilt(string idxMacchina, int gg, double durataMin)
        {
            // setup parametri costanti
            string source = "DB";
            Stopwatch sw = new Stopwatch();
            sw.Start();
            List<FermiNonQualModel> result = new List<FermiNonQualModel>();
            // cerco in _redisConn...
            string currKey = $"{redisBaseKey}:FNQ:{idxMacchina}:{gg}:{durataMin:N0}";
            RedisValue rawData = await _redisDb.StringGetAsync(currKey);
            if (rawData.HasValue)
            {
                result = JsonConvert.DeserializeObject<List<FermiNonQualModel>>($"{rawData}");
                source = "REDIS";
            }
            else
            {
                result = dbTabController.FermiNonQualificatiFilt(idxMacchina, gg, durataMin);
                // serializzo e salvo...
                rawData = JsonConvert.SerializeObject(result);
                await _redisDb.StringSetAsync(currKey, rawData, FastCache);
            }
            if (result == null)
            {
                result = new List<FermiNonQualModel>();
            }
            sw.Stop();
            Log.Debug($"FermiNonQualificatiFilt | {source} | {sw.Elapsed.TotalMilliseconds}ms");
            return result;
        }

        /// <summary>
        /// Pulizia cache Redis (tutta)
        /// </summary>
        /// <returns></returns>
        public async Task<bool> FlushCache()
        {
            RedisValue pattern = new RedisValue($"{redisBaseKey}:*");
            bool answ = await ExecFlushRedisPatternAsync(pattern);
            return answ;
        }

        /// <summary>
        /// Pulizia cache Redis per chiave specifica (da redisBaseKey...)
        /// </summary>
        /// <returns></returns>
        public async Task<bool> FlushCache(string KeyReq)
        {
            RedisValue pattern = new RedisValue($"{redisBaseKey}:{KeyReq}:*");
            bool answ = await ExecFlushRedisPatternAsync(pattern);
            return answ;
        }

        /// <summary>
        /// Flush di tutta la cache relativa ad i dati ODL/PODL
        /// </summary>
        /// <returns></returns>
        public async Task FlushOdlCache()
        {
            await FlushCache("ODL");
            await FlushCache("PODL");
            await FlushCache("VSODL");
            await FlushCache("StatoMacc");
            await FlushCache("MSFD");
        }

        public TimeSpan GetKeyTTL(string redKey)
        {
            TimeSpan answ = TimeSpan.FromMinutes(-1);
            try
            {
                answ = _redisDb.KeyTimeToLive(redKey) ?? new TimeSpan();
            }
            catch (Exception exc)
            {
                Log.Info($"Errore GetKeyTTL | currKey: {redKey}{Environment.NewLine}{exc}");
            }
            return answ;
        }

        /// <summary>
        /// Elenco DTO resoconto InsManuali macchina da records dettaglio
        /// </summary>
        /// <param name="listDetail">Dettagli</param>
        /// <returns></returns>
        public List<InsManDayDto> InsManDayDto(List<InsManualiModel> listDetail)
        {
            List<InsManDayDto>? result = new List<InsManDayDto>();
            if (listDetail.Count > 0)
            {
                string idxMacchina = listDetail.FirstOrDefault().IdxMacchina;
                // proietto...
                result = listDetail
                            .GroupBy(x => x.InizioStato.Date)
                            .Select(group => new InsManDayDto
                            {
                                DataRif = group.Key,
                                IdxMacchina = idxMacchina,
                                MinProdTot = group.Sum(item => item.MinProd),
                                PzBuoniTot = group.Sum(item => item.PzBuoni),
                                RatioImport = group.Count(item => item.Imported != null) / group.Count()
                            })
                            .ToList();
            }
            return result;
        }

        /// <summary>
        /// Elimina record + svuotamento cache
        /// </summary>
        /// <param name="currRecord"></param>
        public async Task<bool> InsManDelete(InsManualiModel currRecord)
        {
            bool fatto = false;
            // salvo
            fatto = dbTabController.InsManDelete(currRecord);
            // svuoto cache
            RedisValue pattern = $"{redisBaseKey}:InsMan:*";
            await ExecFlushRedisPatternAsync(pattern);
            return fatto;
        }

        /// <summary>
        /// Riempie eventuali buchi con evento indicato
        /// </summary>
        /// <param name="dtRif">Data per cui effettuare ricalcolo giornata</param>
        /// <param name="listDetail">Record dettaglio giornata</param>
        /// <param name="idxTipoEv">IdxTipo da riempire</param>
        /// <param name="matrOpr">MatrOperatore corrente</param>
        /// <returns></returns>
        public async Task<int> InsManFillMissing(DateTime dtRif, List<InsManualiModel> listDetail, int idxTipoEv, int matrOpr)
        {
            List<InsManualiModel> rec2add = new List<InsManualiModel>();
            InsManualiModel newRec = new InsManualiModel();
            if (listDetail.Count > 0)
            {
                // punto come record attuale il primo
                InsManualiModel currRec = listDetail.FirstOrDefault();

                string idxMacc = currRec.IdxMacchina;
                DateTime periodStart = currRec.InizioStato;
                DateTime periodEnd = currRec.FineStato.Value;

                // se NON parte da mezzanotte metto un "pad iniziale"...
                if (periodStart.TimeOfDay > new TimeSpan(0))
                {
                    // creo record x la durata necessaria
                    newRec = new InsManualiModel()
                    {
                        CodArticolo = "ND",
                        KeyRichiesta = "",
                        IdxMacchina = idxMacc,
                        InizioStato = periodStart.Date,
                        FineStato = periodStart,
                        IdxTipoEv = idxTipoEv,
                        MatrOpr = matrOpr,
                        PzBuoni = 0,
                        TCiclo = 0,
                        MinProd = (decimal)periodStart.TimeOfDay.TotalMinutes
                    };
                    rec2add.Add(newRec);
                }

                // cerco ultimo record... che sia della data odierna!
                currRec = listDetail.Where(x => x.InizioStato.Date == dtRif.Date).LastOrDefault();
                periodStart = currRec.InizioStato;
                periodEnd = currRec.FineStato.Value;
                // se andassi a domani lo "accorcio"...
                if (periodEnd < dtRif.Date.AddDays(1).AddSeconds(-1))
                {
                    // se non arrivo a mezzanotte aggiungo "pad finale"
                    var lastPeriod = TimeSpan.FromHours(24).Subtract(periodEnd.TimeOfDay).TotalMinutes;
                    if (lastPeriod > 1)
                    {
                        // creo record x la durata necessaria
                        newRec = new InsManualiModel()
                        {
                            CodArticolo = "ND",
                            KeyRichiesta = "",
                            IdxMacchina = idxMacc,
                            InizioStato = periodEnd,
                            FineStato = periodEnd.Date.AddDays(1).AddSeconds(-1),
                            IdxTipoEv = idxTipoEv,
                            MatrOpr = matrOpr,
                            PzBuoni = 0,
                            TCiclo = 0,
                            MinProd = (decimal)lastPeriod
                        };
                        rec2add.Add(newRec);
                    }
                }
                // eseguo upsert massivo
                await InsManUpsert(rec2add);
            }
            return rec2add.Count;
        }

        /// <summary>
        /// Elenco insManuali macchina
        /// </summary>
        /// <param name="idxMacchina">Macchina</param>
        /// <param name="dtFrom">Inizio periodo</param>
        /// <param name="dtTo">Fine periodo</param>
        /// <returns></returns>
        public List<InsManualiModel> InsManFilt(string idxMacchina, DateTime dtFrom, DateTime dtTo)
        {
            string source = "DB";
            Stopwatch sw = new Stopwatch();
            sw.Start();
            List<InsManualiModel>? result = new List<InsManualiModel>();
            // cerco in _redisConn...
            string currKey = $"{redisBaseKey}:InsMan:{idxMacchina}:{dtFrom:yyyyMMdd-HHmmss}:{dtTo::yyyyMMdd-HHmmss}";
            RedisValue rawData = _redisDb.StringGet(currKey);
            if (rawData.HasValue)
            {
                result = JsonConvert.DeserializeObject<List<InsManualiModel>>($"{rawData}");
                source = "REDIS";
            }
            else
            {
                result = dbTabController.InsManFilt(idxMacchina, dtFrom, dtTo);
                // serializzo e salvo...
                rawData = JsonConvert.SerializeObject(result);
                _redisDb.StringSet(currKey, rawData, FastCache);
            }
            if (result == null)
            {
                result = new List<InsManualiModel>();
            }
            sw.Stop();
            Log.Debug($"InsManFilt | {source} | {sw.Elapsed.TotalMilliseconds}ms");
            return result;
        }

        /// <summary>
        /// Chiama stored x congelare i dati giornalieri
        /// </summary>
        /// <param name="idxMacchina"></param>
        /// <param name="dtCurr"></param>
        /// <returns></returns>
        public async Task<bool> InsManFreezeDay(string idxMacchina, DateTime dtCurr)
        {
            bool fatto = false;
            Stopwatch sw = new Stopwatch();
            sw.Start();
            Log.Info($"Inizio InsManFreezeDay | idxMacchina: {idxMacchina}");
            // salvo
            fatto = await dbTabController.InsManFreezeDay(idxMacchina, dtCurr);
            // svuoto cache
            RedisValue pattern = $"{redisBaseKey}:InsMan:*";
            await ExecFlushRedisPatternAsync(pattern);
            sw.Stop();
            Log.Info($"Fine InsManFreezeDay | idxMacchina: {idxMacchina} | elapsed: {sw.Elapsed.TotalMilliseconds:N2} ms");
            return fatto;
        }

        /// <summary>
        /// Elenco DTO x plotting seq stati giornaliero
        /// </summary>
        /// <param name="dtRif">Data per cui effettuare ricalcolo giornata</param>
        /// <param name="listDetail">Record dettaglio giornata</param>
        /// <returns></returns>
        public List<ManualStatusDTO> InsManSeqDayStatus(DateTime dtRif, List<InsManualiModel> listDetail)
        {
            List<ManualStatusDTO>? result = new List<ManualStatusDTO>();
            // per sicurezza RIORDINO!
            listDetail = listDetail
                            .Where(x => x.InizioStato.Date == dtRif.Date)
                            .OrderBy(x => x.InizioStato)
                            .ToList();
            if (listDetail.Count > 0)
            {
                DateTime periodStart = listDetail.FirstOrDefault().InizioStato;
                DateTime periodEnd = listDetail.FirstOrDefault().FineStato.Value;
                double duration = 0;
                int lastIdxTipo = -1;
                ManualStatusDTO currRec = new ManualStatusDTO();
                // se NON parte da mezzanotte metto un "pad iniziale"...
                if (periodStart.TimeOfDay > new TimeSpan(0))
                {
                    lastIdxTipo = 0;
                    currRec = new ManualStatusDTO
                    {
                        IdxTipo = lastIdxTipo,
                        CssBlock = "bg-light text-dark",
                        Title = "missing",
                        Value = periodStart.TimeOfDay.TotalMinutes,
                        ValueMax = 1440
                    };
                }
                // ciclo tutti i record, verificando idxTipo...
                foreach (var item in listDetail)
                {
                    if (item.IdxTipoEv != lastIdxTipo)
                    {
                        // aggiungo rec precedente... se > 0
                        if (currRec.Value > 0)
                        {
                            result.Add(currRec);
                        }
                        lastIdxTipo = item.IdxTipoEv;
                        periodStart = item.InizioStato;
                        periodEnd = item.FineStato.Value;
                        //calcolo errore se supero giorno...
                        bool hasError = periodEnd > dtRif.Date.AddDays(1);
                        duration = (double)item.MinProd;
                        currRec = new ManualStatusDTO
                        {
                            IdxTipo = lastIdxTipo,
                            // fare da DB --> anagEventi
                            CssBlock = item.IdxTipoEv == 1 ? "bg-success text-light" : "bg-secondary text-light",
                            Title = $"{periodStart:HH:mm}-{periodEnd:HH:mm}",
                            Value = duration,
                            ValueMax = 1440,
                            HasError = hasError
                        };
                    }
                    else
                    {
                        duration += (double)item.MinProd;
                        periodEnd = item.FineStato.Value;
                        //calcolo errore se supero giorno...
                        bool hasError = periodEnd > dtRif.Date.AddDays(1);
                        currRec = new ManualStatusDTO
                        {
                            IdxTipo = lastIdxTipo,
                            // fare da DB --> anagEventi
                            CssBlock = item.IdxTipoEv == 1 ? "bg-success text-light" : "bg-secondary text-light",
                            Title = $"{periodStart:HH:mm}-{periodEnd:HH:mm}",
                            Value = duration,
                            ValueMax = 1440,
                            HasError = hasError
                        };
                    }
                }
                // aggiungo rec precedente... se > 0
                if (currRec.Value > 0)
                {
                    result.Add(currRec);
                }
                // se non arrivo a mezzanotte aggiungo "pad finale"
                if (periodEnd <= dtRif.Date.AddDays(1).AddSeconds(-1))
                {
                    var deltaFin = TimeSpan.FromHours(24).Subtract(periodEnd.TimeOfDay);
                    if (deltaFin.TotalMinutes > 0.01)
                    {
                        lastIdxTipo = 0;
                        currRec = new ManualStatusDTO
                        {
                            IdxTipo = lastIdxTipo,
                            CssBlock = "bg-light text-dark",
                            Title = "missing",
                            Value = deltaFin.TotalMinutes,
                            ValueMax = 1440
                        };
                        result.Add(currRec);
                    }
                }
            }
            return result;
        }

        /// <summary>
        /// Esegue salvataggio record + svuotamento cache
        /// </summary>
        /// <param name="currRecord"></param>
        public async Task<bool> InsManUpsert(InsManualiModel currRecord)
        {
            bool fatto = false;
            // salvo
            fatto = dbTabController.InsManUpsert(currRecord);
            // svuoto cache
            RedisValue pattern = $"{redisBaseKey}:InsMan:*";
            await ExecFlushRedisPatternAsync(pattern);
            return fatto;
        }

        /// <summary>
        /// Esegue salvataggio record + svuotamento cache
        /// </summary>
        /// <param name="listRecord"></param>
        public async Task<bool> InsManUpsert(List<InsManualiModel> listRecord)
        {
            bool fatto = false;
            // salvo
            fatto = dbTabController.InsManUpsert(listRecord);
            // svuoto cache
            RedisValue pattern = $"{redisBaseKey}:InsMan:*";
            await ExecFlushRedisPatternAsync(pattern);
            return fatto;
        }

        /// <summary>
        /// Recupero info IOB x TAB (da info registrate IOB-WIN--&gt; MP-IO)
        /// </summary>
        /// <param name="IdxMacchina"></param>
        /// <returns></returns>
        public async Task<IOB_data> IobInfoAsync(string IdxMacchina)
        {
            string source = "DB";
            Stopwatch sw = new Stopwatch();
            sw.Start();
            IOB_data? result = new IOB_data();
            // cerco in _redisConn...
            string currKey = RedHashMpIO($"hM2IOB:{IdxMacchina}");
            RedisValue rawData = await _redisDb.StringGetAsync(currKey);
            //if (!string.IsNullOrEmpty($"{rawData}"))
            if (rawData.HasValue)
            {
                result = JsonConvert.DeserializeObject<IOB_data>($"{rawData}");
                source = "REDIS";
            }
            else
            {
                Log.Error($"Errore: non trovato valore <IOB_data> valido in REDIS | key: {currKey}");
                Log.Info($"REDIS | conf: {_redisConn.Configuration}");
                Log.Info($"  --> Valore trovato:{Environment.NewLine}{rawData}");
            }
            if (result == null)
            {
                result = new IOB_data();
                Log.Debug($"Init valore default <IOB_data> | IdxMacchina: {IdxMacchina}");
            }
            sw.Stop();
            Log.Debug($"IobInfoAsync per {IdxMacchina} | {source} | {sw.Elapsed.TotalMilliseconds}ms");
            return result;
        }

        /// Elenco PODL macchina </summary> <param name="idxMacchina">Macchina</param> <param
        /// name="onlyFree">Solo disponibili (1) o tutte (0)</param> <param
        /// name="codGruppo">Gruppo</param> <returns></returns>
        public async Task<List<PODLExpModel>> ListPODLByMacc(string idxMacchina, bool onlyFree, bool onlyDirect)
        {
            string source = "DB";
            Stopwatch sw = new Stopwatch();
            sw.Start();
            List<PODLExpModel>? result = new List<PODLExpModel>();
            // cerco in _redisConn...
            string currKey = $"{redisBaseKey}:PODL:{idxMacchina}:{onlyFree}:{onlyDirect}";
            RedisValue rawData = await _redisDb.StringGetAsync(currKey);
            if (rawData.HasValue)
            {
                result = JsonConvert.DeserializeObject<List<PODLExpModel>>($"{rawData}");
                source = "REDIS";
            }
            else
            {
                result = await Task.FromResult(dbTabController.ListPODLByMacc(idxMacchina, onlyFree, onlyDirect));
                // serializzo e salvo...
                rawData = JsonConvert.SerializeObject(result);
                await _redisDb.StringSetAsync(currKey, rawData, UltraFastCache);
            }
            if (result == null)
            {
                result = new List<PODLExpModel>();
            }
            sw.Stop();
            Log.Debug($"ListPODLByMacc | {source} | {sw.Elapsed.TotalMilliseconds}ms");
            return result;
        }

        /// <summary>
        /// Elenco parametri validi tab/campo
        /// </summary>
        /// <returns></returns>
        public List<ListValuesModel> ListValuesFilt(string tabName, string fieldName)
        {
            string source = "DB";
            Stopwatch sw = new Stopwatch();
            sw.Start();
            List<ListValuesModel>? result = new List<ListValuesModel>();
            // cerco in _redisConn...
            string currKey = $"{redisBaseKey}:ListVal:{tabName}:{fieldName}";
            RedisValue rawData = _redisDb.StringGet(currKey);
            if (rawData.HasValue)
            {
                result = JsonConvert.DeserializeObject<List<ListValuesModel>>($"{rawData}");
                source = "REDIS";
            }
            else
            {
                result = dbTabController.ListValuesFilt(tabName, fieldName);
                // serializzo e salvo...
                rawData = JsonConvert.SerializeObject(result);
                _redisDb.StringSet(currKey, rawData, UltraLongCache);
            }
            if (result == null)
            {
                result = new List<ListValuesModel>();
            }
            sw.Stop();
            Log.Debug($"ListValuesFilt | {source} | {sw.Elapsed.TotalMilliseconds}ms");
            return result;
        }

        /// <summary>
        /// Elenco lotti esterni presenti sul db di ARCA
        /// </summary>
        /// <param name="codArt">Codice articolo</param>
        /// <param name="codLotto">Codice lotto</param>
        /// <param name="codMagazzino">Codice magazzino</param>
        /// <returns></returns>
        public async Task<List<AnagLottiArca>> LottoEsterno(string codArt, string codLotto, string codMagazzino)
        {
            // setup parametri costanti
            string source = "DB";
            Stopwatch sw = new Stopwatch();
            sw.Start();
            List<AnagLottiArca> result = new List<AnagLottiArca>();
            // cerco in _redisConn...
            string currKey = $"{redisBaseKey}:LottoExt:{codMagazzino}:{codArt}:{codLotto}";
            RedisValue rawData = await _redisDb.StringGetAsync(currKey);
            if (rawData.HasValue)
            {
                result = JsonConvert.DeserializeObject<List<AnagLottiArca>>($"{rawData}");
                source = "REDIS";
            }
            else
            {
                result = dbInveController.LottoEsterno(codArt, codLotto, codMagazzino);
                // serializzo e salvo...
                rawData = JsonConvert.SerializeObject(result);
                await _redisDb.StringSetAsync(currKey, rawData, UltraLongCache);
            }
            if (result == null)
            {
                result = new List<AnagLottiArca>();
            }
            sw.Stop();
            Log.Debug($"LottoEsterno | {source} | {sw.Elapsed.TotalMilliseconds}ms");
            return result;
        }

        /// <summary>
        /// Effettua ricalcolo MSE x macchina indicata
        /// </summary>
        /// <param name="idxMacchina">idx macchina da confermare</param>
        /// <param name="insEnabled">Abilitazione insert ev macchina</param>
        /// <returns></returns>
        public bool MacchinaSetInsEnab(string idxMacchina, bool insEnabled)
        {
            bool answ = dbTabController.MacchinaSetInsEnab(idxMacchina, insEnabled);
            return answ;
        }

        /// <summary>
        /// Intera tabella relazione master/slave in machine (gestione setup master --&gt; slave)
        /// </summary>
        /// <returns></returns>
        public async Task<List<Macchine2SlaveModel>> Macchine2Slave()
        {
            // setup parametri costanti
            string source = "DB";
            Stopwatch sw = new Stopwatch();
            sw.Start();
            List<Macchine2SlaveModel> result = new List<Macchine2SlaveModel>();
            // cerco in _redisConn...
            string currKey = $"{redisBaseKey}:Mach2Slave";
            RedisValue rawData = await _redisDb.StringGetAsync(currKey);
            //if (!string.IsNullOrEmpty($"{rawData}"))
            if (rawData.HasValue)
            {
                result = JsonConvert.DeserializeObject<List<Macchine2SlaveModel>>($"{rawData}");
                source = "REDIS";
            }
            else
            {
                result = dbTabController.Macchine2Slave();
                // serializzo e salvo...
                rawData = JsonConvert.SerializeObject(result);
                await _redisDb.StringSetAsync(currKey, rawData, UltraFastCache);
            }
            if (result == null)
            {
                result = new List<Macchine2SlaveModel>();
            }
            sw.Stop();
            Log.Debug($"Macchine2Slave | {source} | {sw.Elapsed.TotalMilliseconds}ms");
            return result;
        }

        /// <summary>
        /// Elenco MacchineModel dato operatore secondo gruppi (macchine/operatore)
        /// </summary>
        /// <param name="MatrOpr"></param>
        /// <returns></returns>
        public async Task<List<MacchineModel>> MacchineByMatrOper(int MatrOpr)
        {
            int rndWait = rnd.Next(0, 2);
            await Task.Delay(rndWait);
            // setup parametri costanti
            string source = "DB";
            Stopwatch sw = new Stopwatch();
            sw.Start();
            List<MacchineModel> result = new List<MacchineModel>();
            // cerco in _redisConn...
            string currKey = $"{redisBaseKey}:MachByMatOp:{MatrOpr}";
            RedisValue rawData = _redisDb.StringGet(currKey);
            //if (!string.IsNullOrEmpty($"{rawData}"))
            if (rawData.HasValue)
            {
                result = JsonConvert.DeserializeObject<List<MacchineModel>>($"{rawData}");
                source = "REDIS";
            }
            else
            {
                result = dbTabController.MacchineByMatrOper(MatrOpr);
                // serializzo e salvo...
                rawData = JsonConvert.SerializeObject(result);
                _redisDb.StringSet(currKey, rawData, UltraLongCache);
            }
            if (result == null)
            {
                result = new List<MacchineModel>();
            }
            sw.Stop();

            string callName = $"MacchineByMatrOper.{source}";
            int numRec = esCollect.RecordCall(callName, sw.Elapsed.TotalMilliseconds);
            if (numRec >= nRecLog)
            {
                Log.Debug(esCollect.GetCallSum(callName, true));
            }
            return result;
        }

        /// <summary>
        /// Lista parametri correnti (ObjItemDTO) della macchina
        /// </summary>
        /// <param name="idxMacchina"></param>
        /// <returns></returns>
        public List<ObjItemDTO> MachineParamList(string idxMacchina)
        {
            // setup parametri costanti
            string source = "NA";
            Stopwatch sw = new Stopwatch();
            sw.Start();
            List<ObjItemDTO>? result = new List<ObjItemDTO>();
            // cerco in _redisConn...
            string currKey = RedHashMpIO($"CurrentParameters:{idxMacchina}");
            RedisValue rawData = _redisDb.StringGet(currKey);
            if (rawData.HasValue && rawData.Length() > 2)
            {
                var rawVal = JsonConvert.DeserializeObject<List<ObjItemDTO>>($"{rawData}");
                // ordino!
                result = rawVal
                            .OrderBy(x => x.displOrdinal)
                            .ThenBy(x => x.description)
                            .ToList();
                source = "REDIS";
            }
            if (result == null)
            {
                result = new List<ObjItemDTO>();
                source = "NONE";
            }
            sw.Stop();
            Log.Debug($"CurrParamList | {source} | {sw.Elapsed.TotalMilliseconds}ms");
            return result;
        }

        /// <summary>
        /// Aggiornamento parametro per macchina
        /// </summary>
        /// <param name="idxMacchina"></param>
        /// <param name="uid">UID del parametro macchina come definito in file json</param>
        /// <param name="reqValue"></param>
        /// <returns></returns>
        public bool MachineParamUpdate(string idxMacchina, string uid, string reqValue)
        {
            bool answ = false;
            // recupero items...
            List<ObjItemDTO> dcList = MachineParamList(idxMacchina);
            List<ObjItemDTO> list2Update = new List<ObjItemDTO>();
            // cerco quello da aggiornare
            var trovato = dcList.Find(obj => obj.uid == uid);
            // se non trova --> crea ed aggiunge...
            if (trovato == null)
            {
                dcList.Add(new ObjItemDTO() { uid = uid });
                trovato = dcList.Find(obj => obj.uid == uid);
            }

            // se trovato procedo
            if (trovato != null)
            {
                // aggiorno valore richiesto + dt richiesta
                trovato.reqValue = reqValue;
                trovato.lastRequest = DateTime.Now;
                list2Update.Add(trovato);
                MachineParamUpsert(idxMacchina, list2Update);

                // accodo in task 2 exe la richiesta di processing
                addTask4Machine(idxMacchina, Enums.taskType.setParameter, trovato.uid);

                // salvo ANCHE il valore di setup ASSOCIATO...
                System.Enum.TryParse(trovato.uid, out Enums.taskType currTask);
                //taskType currTask = (taskType)System.Enum.Parse(typeof(taskType), trovato.uid);
                addTask4Machine(idxMacchina, currTask, reqValue);

                answ = true;
            }
            return answ;
        }

        /// <summary>
        /// Effettua UPSERT elenco parametri correnti x IOB (se c'è UPDATE, se manca ADD)
        /// </summary>
        /// <param name="idxMacchina"></param>
        /// <param name="innovations"></param>
        /// <returns></returns>
        public bool MachineParamUpsert(string idxMacchina, List<ObjItemDTO> innovations)
        {
            bool answ = false;
            if (innovations != null)
            {
                Log.Info($"upsertCurrObjItems | idxMacchina: {idxMacchina} | {innovations.Count} innovations");
                // leggo i valori attuali...
                List<ObjItemDTO> actValues = MachineParamList(idxMacchina);
                // per ogni valore passatomi faccio insert o update rispetto elenco valori correnti
                // in REDIS
                foreach (var item in actValues)
                {
                    // cerco nelle innovazioni SE CI SIA il valore...
                    var trovato = innovations.Find(obj => obj.uid == item.uid);
                    // se non trovato nelle innovazioni...
                    if (trovato == null)
                    {
                        // lo ri-aggiungo x non perderlo
                        innovations.Add(item);
                        Log.Trace($"innovations | add | item.uid: {item.uid} | item.value: {item.value}");
                    }
                    // altrimenti aggiorno campo (non trasmesso) name e tengo il resto...
                    else
                    {
                        trovato.name = item.name;
                        Log.Info($"innovations | update | item.uid: {item.uid} | item.value: {item.value} --> {trovato.value} ");
                    }
                }
                // serializzo e salvo
                string serVal = JsonConvert.SerializeObject(innovations);
                string currKey = RedHashMpIO($"CurrentParameters:{idxMacchina}");
                RedisValue rawData = _redisDb.StringSet(currKey, serVal);
            }
            return answ;
        }

        /// <summary>
        /// Restitusice elenco KVP dei TASK SALVATI (da passare a IOB-WIN) per l'impianto indicato
        /// </summary>
        /// <param name="idxMacchina"></param>
        /// s
        /// <returns></returns>
        public Dictionary<string, string> mSavedTaskMacchina(string idxMacchina)
        {
            // hard coded dimensione vettore DatiMacchine
            Dictionary<string, string> answ = new Dictionary<string, string>();
            // ORA recupero da memoria _redisConn...
            try
            {
                var currKey = (RedisKey)savedTaskHash(idxMacchina);
                answ = redisHashDictGet(currKey);
            }
            catch (Exception exc)
            {
                Log.Info($"Errore in recupero dati SAVED TASK x Redis mSavedTaskMacchina | idxMacchina {idxMacchina}{Environment.NewLine}{exc}");
            }
            return answ;
        }

        /// <summary>
        /// Recupera un valore MSE x una macchina sub specifica
        /// </summary>
        /// <param name="idxMacc"></param>
        /// <param name="idxMacchSub"></param>
        /// <param name="forceDb"></param>
        /// <returns></returns>
        public MappaStatoExplModel MseGetSub(string idxMacc, string idxMacchSub, bool forceDb)
        {
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            MappaStatoExplModel result = new MappaStatoExplModel();
            // cerco in _redisConn...
            string currKey = $"{Constants.redisMseKeySingle}:{idxMacchSub}";
            RedisValue rawData = _redisDb.StringGet(currKey);
            if (rawData.HasValue && !forceDb)
            {
                result = JsonConvert.DeserializeObject<MappaStatoExplModel>($"{rawData}");
                stopWatch.Stop();
                TimeSpan ts = stopWatch.Elapsed;
                Log.Debug($"Read from REDIS: {ts.TotalMilliseconds}ms");
            }
            else
            {
                var rawResult = dbTabController.MseGetSub(idxMacc, idxMacchSub);
                if (rawResult != null && rawResult.Count > 0)
                {
                    result = rawResult.FirstOrDefault();
                }
                // serializzo e salvo...
                rawData = JsonConvert.SerializeObject(result);
                _redisDb.StringSet(currKey, rawData, UltraFastCache);
                stopWatch.Stop();
                TimeSpan ts = stopWatch.Elapsed;
                Log.Debug($"Read from DB: {ts.TotalMilliseconds}ms");
            }
            if (result == null)
            {
                result = new MappaStatoExplModel();
            }
            return result;
        }

        /// <summary>
        /// Invio notifica dati invalidati x impianto
        /// </summary>
        /// <param name="idxMacchina"></param>
        public void NotifyDataInvalidated(string idxMacchina)
        {
            if (DataInvalidated != null)
            {
                // messaggio
                ReloadEventArgs rea = new ReloadEventArgs(idxMacchina);
                DataInvalidated.Invoke(this, rea);
            }
        }

        /// <summary>
        /// Invio notifica rilettura (con parametro)
        /// </summary>
        /// <param name="message"></param>
        public void NotifyReloadRequest(string message)
        {
            if (ReloadRequest != null)
            {
                // messaggio
                ReloadEventArgs rea = new ReloadEventArgs(message);
                ReloadRequest.Invoke(this, rea);
            }
        }

        /// <summary>
        /// ODL da key
        /// </summary>
        /// <param name="idxOdl"></param>
        /// <param name="onlyUnused"></param>
        /// <returns></returns>
        public async Task<ODLExpModel> OdlByIdx(int idxOdl, bool onlyUnused)
        {
            int rndWait = rnd.Next(0, 3);
            await Task.Delay(rndWait);
            string source = "DB";
            Stopwatch sw = new Stopwatch();
            sw.Start();
            ODLExpModel result = new ODLExpModel();
            // cerco in _redisConn...
            string currKey = $"{redisBaseKey}:ODL:{idxOdl}:{onlyUnused}";
            RedisValue rawData = _redisDb.StringGet(currKey);
#if false
            RedisValue rawData = await redisDb.StringGetAsync(currKey);
#endif
            if (rawData.HasValue)
            {
                result = JsonConvert.DeserializeObject<ODLExpModel>($"{rawData}");
                source = "REDIS";
            }
            else
            {
                var listRes = dbTabController.OdlByIdx(idxOdl, onlyUnused);
#if false
                var listRes = await Task.FromResult(dbTabController.OdlByIdx(idxOdl, onlyUnused));
#endif
                result = listRes.FirstOrDefault();
                // serializzo e salvo...
                rawData = JsonConvert.SerializeObject(result);
                _redisDb.StringSet(currKey, rawData, FastCache);
#if false
                await redisDb.StringSetAsync(currKey, rawData, FastCache);
#endif
            }
            if (result == null)
            {
                result = new ODLExpModel();
            }
            sw.Stop();
#if false
            Log.Debug($"OdlByIdx | {idxOdl} | {source} | {sw.Elapsed.TotalMilliseconds}ms");
#endif
            string callName = $"OdlByIdx.{source}";
            int numRec = esCollect.RecordCall(callName, sw.Elapsed.TotalMilliseconds);
            if (numRec >= nRecLog)
            {
                Log.Debug(esCollect.GetCallSum(callName, true));
            }
            return result;
        }

        /// <summary>
        /// Clear operazione setup ODL (annullamento)
        /// </summary>
        /// <param name="idxODL"></param>
        /// <param name="idxMacchina"></param>
        /// <returns></returns>
        public async Task<bool> OdlClearSetup(int idxODL, string idxMacchina)
        {
            bool answ = false;
            try
            {
                // inserisco evento
                answ = dbTabController.OdlClearSetup(idxODL, idxMacchina);
                await FlushOdlCache();
            }
            catch (Exception exc)
            {
                string logMsg = $"Eccezione in OdlUpdate | idxODL: {idxODL} | idxMacchina: {idxMacchina}{Environment.NewLine}{exc}";
                Log.Error(logMsg);
            }
            return answ;
        }

        /// <summary>
        /// ODL corrente macchina
        /// </summary>
        /// <param name="idxMacchina"></param>
        /// <returns></returns>
        public async Task<ODLExpModel> OdlCurrByMacc(string idxMacchina, bool forceDb)
        {
            // pausa random x evitare sovrapposizioni...
            int rndWait = rnd.Next(0, 3);
            await Task.Delay(rndWait);
            string source = "DB";
            Stopwatch sw = new Stopwatch();
            sw.Start();
            ODLExpModel result = new ODLExpModel();
            // se vuoto esco subito...
            if (!string.IsNullOrEmpty(idxMacchina))
            {
                // cerco in _redisConn...
                string currKey = $"{redisBaseKey}:ODL:{idxMacchina}:CURR";
                RedisValue rawData = _redisDb.StringGet(currKey);
#if false
                RedisValue rawData = await redisDb.StringGetAsync(currKey);
#endif
                if (rawData.HasValue && !forceDb)
                {
                    result = JsonConvert.DeserializeObject<ODLExpModel>($"{rawData}");
                    source = "REDIS";
                }
                else
                {
                    var listRes = dbTabController.OdlCurrByMacc(idxMacchina);
#if false
                    var listRes = await Task.FromResult(dbTabController.OdlCurrByMacc(idxMacchina));
#endif
                    result = listRes.FirstOrDefault();
                    // serializzo e salvo...
                    rawData = JsonConvert.SerializeObject(result);
                    _redisDb.StringSet(currKey, rawData, FastCache);
#if false
                    await redisDb.StringSetAsync(currKey, rawData, FastCache);
#endif
                }
                if (result == null)
                {
                    result = new ODLExpModel();
                }
                sw.Stop();
#if false
                Log.Debug($"OdlCurrByMacc | {source} | {idxMacchina} | {sw.Elapsed.TotalMilliseconds}ms");
#endif
                string callName = $"OdlCurrByMaccAsync.{source}";
                int numRec = esCollect.RecordCall(callName, sw.Elapsed.TotalMilliseconds);
                if (numRec >= nRecLog)
                {
                    Log.Debug(esCollect.GetCallSum(callName, true));
                }
            }
            else
            {
                Log.Trace("idxMacchina vuoto!");
            }
            return result;
        }

        /// <summary>
        /// Attrezzo stesso ODL dell'altra tavola
        /// </summary>
        /// <param name="idxODL"></param>
        /// <param name="matrOpr"></param>
        /// <param name="idxMacchinaTo"></param>
        /// <returns></returns>
        public async Task<bool> OdlDividiDaAltraTavola(int idxODL, int matrOpr, string idxMacchinaTo)
        {
            bool answ = false;
            try
            {
                // inserisco evento
                answ = dbTabController.OdlDividiDaAltraTavola(idxODL, matrOpr, idxMacchinaTo);
                await FlushOdlCache();
            }
            catch (Exception exc)
            {
                string logMsg = $"Eccezione in OdlDividiDaAltraTavola | idxODL: {idxODL} | matrOpr: {matrOpr} | idxMacchinaTo: {idxMacchinaTo}{Environment.NewLine}{exc}";
                Log.Error(logMsg);
            }
            return answ;
        }

        /// <summary>
        /// Registro fine prod ODL
        /// </summary>
        /// <param name="idxODL"></param>
        /// <param name="idxMacchina"></param>
        /// <param name="dtRif"></param>
        /// <returns></returns>
        public async Task<bool> OdlFineProd(int idxODL, string idxMacchina, DateTime dtRif)
        {
            bool answ = false;
            try
            {
                // inserisco evento
                answ = dbTabController.OdlFineProd(idxODL, idxMacchina, dtRif);
                await FlushOdlCache();
            }
            catch (Exception exc)
            {
                string logMsg = $"Eccezione in OdlFineProd | idxODL: {idxODL} | idxMacchina: {idxMacchina} | dtRif: {dtRif}{Environment.NewLine}{exc}";
                Log.Error(logMsg);
            }
            return answ;
        }

        /// <summary>
        /// Fix ODL per macchine SLAVE
        /// </summary>
        /// <param name="idxMacchina"></param>
        /// <param name="numDayPrev"></param>
        /// <param name="doInsert"></param>
        /// <returns></returns>
        public async Task<bool> OdlFixMachineSlave(string idxMacchina, int numDayPrev, int doInsert)
        {
            bool answ = false;
            try
            {
                // inserisco evento
                answ = dbTabController.OdlFixMachineSlave(idxMacchina, numDayPrev, doInsert);
                await FlushOdlCache();
            }
            catch (Exception exc)
            {
                string logMsg = $"Eccezione in ODLfixMachineSlave | idxMacchina: {idxMacchina} | numDayPrev: {numDayPrev} | doInsert: {doInsert}{Environment.NewLine}{exc}";
                Log.Error(logMsg);
            }
            return answ;
        }

        /// <summary>
        /// Setup PODL Postumo
        /// </summary>
        /// <param name="idxODL"></param>
        /// <param name="matrOpr"></param>
        /// <param name="idxMacchina"></param>
        /// <param name="tcRich"></param>
        /// <param name="pzPallet"></param>
        /// <param name="note"></param>
        /// <returns></returns>
        public async Task<bool> OdlInizioSetup(int idxODL, int matrOpr, string idxMacchina, decimal tcRich, int pzPallet, string note)
        {
            bool answ = false;
            try
            {
                // inserisco evento
                answ = dbTabController.OdlInizioSetup(idxODL, matrOpr, idxMacchina, tcRich, pzPallet, note);
                await FlushOdlCache();
            }
            catch (Exception exc)
            {
                string logMsg = $"Eccezione in OdlInizioSetup | matrOpr: {matrOpr} | idxODL: {idxODL} | idxMacchina: {idxMacchina}{Environment.NewLine}{exc}";
                Log.Error(logMsg);
            }
            return answ;
        }

        /// <summary>
        /// Ultimo ODL data macchina
        /// </summary>
        /// <param name="idxMacchina"></param>
        /// <param name="forceDb"></param>
        /// <returns></returns>
        public ODLModel OdlLastByMacc(string idxMacchina, bool forceDb)
        {
            string source = "DB";
            Stopwatch sw = new Stopwatch();
            sw.Start();
            ODLModel result = new ODLModel();
            // cerco in _redisConn...
            string currKey = $"{redisBaseKey}:ODL:{idxMacchina}:LAST";
            RedisValue rawData = _redisDb.StringGet(currKey);
            if (rawData.HasValue && !forceDb)
            {
                result = JsonConvert.DeserializeObject<ODLModel>($"{rawData}");
                source = "REDIS";
            }
            else
            {
                var results = dbTabController.OdlLastByMacc(idxMacchina);
                // riordino
                result = results.FirstOrDefault();
                // serializzo e salvo...
                rawData = JsonConvert.SerializeObject(result);
                _redisDb.StringSet(currKey, rawData, UltraLongCache);
            }
            if (result == null)
            {
                result = new ODLModel();
            }
            sw.Stop();
            Log.Debug($"OdlLastByMacc | {source} | {sw.Elapsed.TotalMilliseconds}ms");
            return result;
        }

        /// <summary>
        /// Elenco ODL data macchina e periodo
        /// </summary>
        /// <param name="idxMacchina"></param>
        /// <param name="dtStart"></param>
        /// <param name="dtEnd"></param>
        /// <returns></returns>
        public async Task<List<ODLExpModel>> OdlListByMaccPeriodo(string idxMacchina, DateTime dtStart, DateTime dtEnd)
        {
            string source = "DB";
            Stopwatch sw = new Stopwatch();
            sw.Start();
            List<ODLExpModel>? result = new List<ODLExpModel>();
            // cerco in _redisConn...
            string currKey = $"{redisBaseKey}:ODL:{idxMacchina}:{dtStart:yyyyMMdd-HHmmss}:{dtEnd:yyyyMMdd-HHmmss}";
            RedisValue rawData = await _redisDb.StringGetAsync(currKey);
            if (rawData.HasValue)
            {
                result = JsonConvert.DeserializeObject<List<ODLExpModel>>($"{rawData}");
                source = "REDIS";
            }
            else
            {
                result = dbTabController.OdlListByMaccPeriodo(idxMacchina, dtStart, dtEnd);
                // riordino
                result = result.OrderByDescending(x => x.DataInizio).ToList();
                // serializzo e salvo...
                rawData = JsonConvert.SerializeObject(result);
                await _redisDb.StringSetAsync(currKey, rawData, FastCache);
            }
            if (result == null)
            {
                result = new List<ODLExpModel>();
            }
            sw.Stop();
            Log.Debug($"OdlListByMaccPeriodo | {source} | {sw.Elapsed.TotalMilliseconds}ms");
            return result;
        }

        /// <summary>
        /// Riapertura ULTIMO ODL data macchina
        /// </summary>
        /// <param name="idxMacchina"></param>
        /// <returns></returns>
        public async Task<ODLModel> OdlReopenOdlMacc(string idxMacchina)
        {
            string source = "DB";
            Stopwatch sw = new Stopwatch();
            sw.Start();
            ODLModel result = new ODLModel();
            // cerco in _redisConn...
            string currKey = $"{redisBaseKey}:ODL:{idxMacchina}:LAST";
            var results = await Task.FromResult(dbTabController.OdlReopenOdlMacc(idxMacchina));
            // riordino
            result = results.FirstOrDefault();
            // svuoto cache
            await FlushOdlCache();
            if (result == null)
            {
                result = new ODLModel();
            }
            sw.Stop();
            Log.Debug($"OdlReopenOdlMacc | {source} | {sw.Elapsed.TotalMilliseconds}ms");
            return result;
        }

        /// <summary>
        /// Setup ODL Postumo
        /// </summary>
        /// <param name="idxODL"></param>
        /// <param name="idxMacchina"></param>
        /// <returns></returns>
        public async Task<bool> OdlSetupPostumo(int idxODL, string idxMacchina)
        {
            bool answ = false;
            try
            {
                // inserisco evento
                answ = await Task.FromResult(dbTabController.OdlSetupPostumo(idxODL, idxMacchina));
                await FlushOdlCache();
            }
            catch (Exception exc)
            {
                string logMsg = $"Eccezione in OdlSetupPostumo | macchina: {idxMacchina} | idxODL: {idxODL}{Environment.NewLine}{exc}";
                Log.Error(logMsg);
            }
            return answ;
        }

        /// <summary>
        /// Setup ODL Postumo
        /// </summary>
        /// <param name="idxPromOdl"></param>
        /// <param name="matrOpr"></param>
        /// <param name="idxMacchina"></param>
        /// <returns></returns>
        public async Task<bool> OdlSetupPromPostuma(int idxPromOdl, int matrOpr, string idxMacchina)
        {
            bool answ = false;
            try
            {
                // inserisco evento
                answ = await Task.FromResult(dbTabController.OdlSetupPromPostuma(idxPromOdl, matrOpr, idxMacchina));
                await FlushOdlCache();
            }
            catch (Exception exc)
            {
                string logMsg = $"Eccezione in OdlSetupPromPostuma | macchina: {idxMacchina} | idxPromOdl: {idxPromOdl} | MatrOpr: {matrOpr}{Environment.NewLine}{exc}";
                Log.Error(logMsg);
            }
            return answ;
        }

        /// <summary>
        /// Split ODL
        /// </summary>
        /// <param name="idxODL"></param>
        /// <param name="matrOpr"></param>
        /// <param name="idxMacchina"></param>
        /// <param name="TCRich"></param>
        /// <param name="pzPallet"></param>
        /// <param name="note"></param>
        /// <param name="startNewOdl"></param>
        /// <param name="qtyRich"></param>
        /// <returns></returns>
        public async Task<bool> OdlSplit(int idxODL, int matrOpr, string idxMacchina, decimal TCRich, int pzPallet, string note, bool startNewOdl, int qtyRich)
        {
            bool answ = false;
            try
            {
                // inserisco evento
                answ = await Task.FromResult(dbTabController.OdlSplit(idxODL, matrOpr, idxMacchina, TCRich, pzPallet, note, startNewOdl, qtyRich));
                await FlushOdlCache();
            }
            catch (Exception exc)
            {
                string logMsg = $"Eccezione in OdlSplit | macchina: {idxMacchina} | idxODL: {idxODL}{Environment.NewLine}{exc}";
                Log.Error(logMsg);
            }
            return answ;
        }

        /// <summary>
        /// Update ODL (es: in setup x chiusura attrezzaggio)
        /// </summary>
        /// <param name="idxODL"></param>
        /// <param name="matrOpr"></param>
        /// <param name="tCRichAttr"></param>
        /// <param name="pzPallet"></param>
        /// <param name="note"></param>
        /// <returns></returns>
        public async Task<bool> OdlUpdate(int idxODL, int matrOpr, decimal tCRichAttr, int pzPallet, string note)
        {
            bool answ = false;
            try
            {
                // inserisco evento
                answ = dbTabController.OdlUpdate(idxODL, matrOpr, tCRichAttr, pzPallet, note);
                await FlushOdlCache();
            }
            catch (Exception exc)
            {
                string logMsg = $"Eccezione in OdlUpdate | idxODL: {idxODL} | matrOpr: {matrOpr} | tCRichAttr: {tCRichAttr} | pzPallet: {pzPallet} | note: {note}{Environment.NewLine}{exc}";
                Log.Error(logMsg);
            }
            return answ;
        }

        /// <summary>
        /// Delete dell'oggetto opr serializzato
        /// </summary>
        /// <param name="matrOpr"></param>
        /// <returns></returns>
        public async Task<bool> OperatoreDeleteRedis(int matrOpr, Guid DevGuid)
        {
            string source = "REDIS";
            Stopwatch sw = new Stopwatch();
            sw.Start();
            bool answ = false;
            // cerco in _redisConn...
            string currKey = $"{redisUserDataKey}:CurrOpr:{matrOpr}:CurrDevGuid:{DevGuid}";
            RedisValue rawData = await _redisDb.StringGetAsync(currKey);
            if (rawData.HasValue)
            {
                var done = await ExecFlushRedisPatternAsync(currKey);
                if (done)
                {
                    answ = true;
                }
            }
            sw.Stop();
            Log.Debug($"OperatoreDeleteRedis | {source} | {sw.Elapsed.TotalMilliseconds}ms");
            await Task.Delay(1);
            return answ;
        }

        /// <summary>
        /// Legge l'oggetto operatore+device loggato e restituisce la sua TTL
        /// </summary>
        /// <param name="matrOpr"></param>
        /// <param name="currDevGuid"></param>
        /// <returns></returns>
        public TimeSpan OperatoreGetGuidTTL(int matrOpr, Guid currDevGuid)
        {
            TimeSpan answ = new TimeSpan();
            // cerco in _redisConn...
            string currKey = $"{redisUserDataKey}:CurrOpr:{matrOpr}:CurrDevGuid:{currDevGuid}";
            answ = GetKeyTTL(currKey);
            return answ;
        }

        /// <summary>
        /// Legge l'oggetto operatore loggato
        /// </summary>
        /// <param name="matrOpr"></param>
        /// <returns></returns>
        public async Task<string> OperatoreGetRedis(int matrOpr, Guid currDevGuid)
        {
            string source = "REDIS";
            Stopwatch sw = new Stopwatch();
            sw.Start();
            string answ = "";
            // cerco in _redisConn...
            string currKey = $"{redisUserDataKey}:CurrOpr:{matrOpr}:CurrDevGuid:{currDevGuid}";
            RedisValue rawData = await _redisDb.StringGetAsync(currKey);
            if (rawData.HasValue)
            {
                answ = rawData;
            }
            if (answ == null)
            {
                answ = "";
            }
            sw.Stop();
            Log.Debug($"OperatoreGetRedis | {source} | {sw.Elapsed.TotalMilliseconds}ms");
            await Task.Delay(1);
            return answ;
        }

        /// <summary>
        /// Log in operatore
        /// </summary>
        /// <param name="matrOpr">matricola operatore</param>
        /// <param name="authKey">Auth Key</param>
        /// <returns></returns>
        public async Task<AnagOperatoriModel> OperatoreSearch(int matrOpr, string authKey)
        {
            string source = "DB";
            Stopwatch sw = new Stopwatch();
            sw.Start();
            AnagOperatoriModel answ = null;
            answ = dbTabController.OperatoreSearch(matrOpr, authKey);
            if (answ == null)
            {
                answ = new AnagOperatoriModel();
            }
            sw.Stop();
            Log.Debug($"LoginOperatore | {source} | {sw.Elapsed.TotalMilliseconds}ms");
            await Task.Delay(1);
            return answ;
        }

        /// <summary>
        /// legge l'hash dell'oggetto curr opr
        /// </summary>
        /// <param name="currOpr"></param>
        /// <returns></returns>
        public async Task<string> OperatoreSetRedis(int matrOpr, string currOpr, Guid currDevGuid)
        {
            setExpDays();
            string source = "REDIS";
            Stopwatch sw = new Stopwatch();
            sw.Start();
            string answ = "";
            // cerco in _redisConn...
            string currKey = $"{redisUserDataKey}:CurrOpr:{matrOpr}:CurrDevGuid:{currDevGuid}";
            //RedisValue rawData = await _redisDb.StringGetAsync(currKey);
            // serializzo e salvo...
            //rawData = JsonConvert.SerializeObject(currOpr);
            answ = currOpr;
            //var encrData = SteamCrypto.EncryptString(rawData, passPhrase);
            await _redisDb.StringSetAsync(currKey, currOpr, ConfigCache);
            if (answ == null)
            {
                answ = "";
            }
            sw.Stop();
            Log.Debug($"OperatoreSetRedis | {source} | {sw.Elapsed.TotalMilliseconds}ms");
            await Task.Delay(1);
            return answ;
        }

        /// <summary>
        /// Stato prod macchina
        /// </summary>
        /// <param name="idxMacchina"></param>
        /// <returns></returns>
        public async Task<List<PzProdModel>> PezziProdMacchina(string idxMacchina)
        {
            // setup parametri costanti
            string source = "DB";
            Stopwatch sw = new Stopwatch();
            sw.Start();
            List<PzProdModel> result = new List<PzProdModel>();
            // cerco in _redisConn...
            string currKey = $"{redisBaseKey}:PzProd:{idxMacchina}";
            RedisValue rawData = await _redisDb.StringGetAsync(currKey);
            if (rawData.HasValue)
            {
                result = JsonConvert.DeserializeObject<List<PzProdModel>>($"{rawData}");
                source = "REDIS";
            }
            else
            {
                result = dbTabController.PezziProdMacchina(idxMacchina);
                // serializzo e salvo...
                rawData = JsonConvert.SerializeObject(result);
                await _redisDb.StringSetAsync(currKey, rawData, UltraFastCache);
            }
            if (result == null)
            {
                result = new List<PzProdModel>();
            }
            sw.Stop();
            Log.Debug($"PezziProdMacchina | {source} | {sw.Elapsed.TotalMilliseconds}ms");
            return result;
        }

        /// <summary>
        /// Avvio setup ODL da PODL
        /// </summary>
        /// <param name="editRec"></param>
        /// <param name="matrOpr"></param>
        /// <param name="tcRich"></param>
        /// <param name="pzPallet"></param>
        /// <param name="note"></param>
        /// <returns></returns>
        public async Task<bool> PODL_startSetup(PODLExpModel editRec, int matrOpr, decimal tcRich, int pzPallet, string note, DateTime dtEvent)
        {
            bool answ = false;
            try
            {
                // inserisco evento
                answ = dbTabController.PODL_startSetup(editRec, matrOpr, tcRich, pzPallet, note, dtEvent);
                await FlushOdlCache();
            }
            catch (Exception exc)
            {
                string logMsg = $"Eccezione in PODL_startSetup | matrOpr: {matrOpr} | idxPODL: {editRec.IdxPromessa}{Environment.NewLine}{exc}";
                Log.Error(logMsg);
            }
            return answ;
        }

        /// <summary>
        /// Recupero PODL da chiave
        /// </summary>
        /// <param name="idxPODL"></param>
        /// <returns></returns>
        public async Task<PODLExpModel> PODLExp_getByKey(int idxPODL)
        {
            string source = "DB";
            // pausa random x evitare sovrapposizioni...
            int rndWait = rnd.Next(0, 3);
            await Task.Delay(rndWait);
            Stopwatch sw = new Stopwatch();
            sw.Start();
            PODLExpModel result = new PODLExpModel();
            // cerco in _redisConn...
            string currKey = $"{redisBaseKey}:PODL:{idxPODL}";
            RedisValue rawData;
            rawData = _redisDb.StringGet(currKey);
#if false
            if (doSync)
            {
                rawData = redisDb.StringGet(currKey);
            }
            else
            {
                rawData = await redisDb.StringGetAsync(currKey);
            }
#endif
            if (rawData.HasValue)
            {
                result = JsonConvert.DeserializeObject<PODLExpModel>($"{rawData}");
                source = "REDIS";
            }
            else
            {
                result = dbTabController.PODLExp_getByKey(idxPODL);
                // serializzo e salvo...
                rawData = JsonConvert.SerializeObject(result);
                _redisDb.StringSet(currKey, rawData, FastCache);
#if false
                if (doSync)
                {
                    result = dbTabController.PODLExp_getByKey(idxPODL);
                }
                else
                {
                    result = await dbTabController.PODLExp_getByKeyAsync(idxPODL);
                }
                //result = await Task.FromResult(dbTabController.PODLExp_getByKey(idxPODL));
                // serializzo e salvo...
                rawData = JsonConvert.SerializeObject(result);
                if (doSync)
                {
                    redisDb.StringSet(currKey, rawData, FastCache);
                }
                else
                {
                    await redisDb.StringSetAsync(currKey, rawData, FastCache);
                }
#endif
            }
            if (result == null)
            {
                result = new PODLExpModel();
            }
            sw.Stop();
#if false
            Log.Debug($"PODL_getByKey | {idxPODL} | {source} | {sw.Elapsed.TotalMilliseconds}ms");
#endif
            string callName = $"PODL_getByKey.{source}";
            int numRec = esCollect.RecordCall(callName, sw.Elapsed.TotalMilliseconds);
            if (numRec >= nRecLog)
            {
                Log.Debug(esCollect.GetCallSum(callName, true));
            }
            return result;
        }

        /// <summary>
        /// Elenco PODL in un istanza KIT dall'ID del parent
        /// </summary>
        /// <param name="IdxPodlParent">IDX PODL parent</param>
        /// <returns></returns>
        public List<PODLExpModel> POdlListByKitParent(int IdxPodlParent)
        {
            List<PODLExpModel>? result = new List<PODLExpModel>();
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            string readType = "DB";
            string currKey = $"{MP.Core.Utils.redisPOdlList}_kit:ByParent:{IdxPodlParent}";
            // cerco in _redisConn dato valore sel idxMaccSel...
            RedisValue rawData = _redisDb.StringGet(currKey);
            if (rawData.HasValue)
            {
                result = JsonConvert.DeserializeObject<List<PODLExpModel>>($"{rawData}");
                readType = "REDIS";
            }
            else
            {
                result = dbTabController.ListPODL_ByKitParent(IdxPodlParent);
                // serializzo e salvo...
                rawData = JsonConvert.SerializeObject(result);
                _redisDb.StringSet(currKey, rawData, LongCache);
            }
            if (result == null)
            {
                result = new List<PODLExpModel>();
            }
            stopWatch.Stop();
            TimeSpan ts = stopWatch.Elapsed;
            Log.Debug($"POdlListByKitParent | Read from {readType}: {ts.TotalMilliseconds}ms");
            return result;
        }

        /// <summary>
        /// Restituisce il contapezzi salvato per la macchina
        /// </summary>
        /// <param name="idxMacchina"></param>
        /// <returns></returns>
        public async Task<int> pzCounter(string idxMacchina)
        {
            int answ = -1;
            string rCall = "";
            saveCallRec("getCounter");
            try
            {
                rCall = _redisDb.StringGet(redHash($"PzCount:{idxMacchina}"));
                if (rCall != "" && rCall != null)
                {
                    int.TryParse(rCall, out answ);
                }
                else
                {
                    answ = await pzCounterTC(idxMacchina);
                    // salvo in _redisConn...
                    await saveCounter(idxMacchina, answ.ToString());
                }
            }
            catch (Exception exc)
            {
                Log.Error($"Eccezione in pzCounter{Environment.NewLine}{exc}");
            }
            return answ;
        }

        /// <summary>
        /// Restituisce il contapezzi come CONTEGGIO da TCRilevati per la macchina
        /// </summary>
        /// <param name="idxMacchina"></param>
        /// <returns></returns>
        public async Task<int> pzCounterTC(string idxMacchina)
        {
            int answ = -1;
            saveCallRec("getCounterTC");
            DateTime dataRif = DateTime.Now;
            var datiProd = await StatoProdMacchinaAsync(idxMacchina, dataRif);
            if (datiProd != null)
            {
                answ = datiProd.PzTotODL;
            }
            return answ;
        }

        /// <summary>
        /// Restituisce elenco RC filtrato
        /// </summary>
        /// <param name="idxMacchina"></param>
        /// <param name="idxODL"></param>
        /// <param name="dataFrom"></param>
        /// <param name="dataTo"></param>
        /// <returns></returns>
        public async Task<List<RegistroControlliModel>> RegControlliFiltAsync(string idxMacchina, int idxODL, DateTime dataFrom, DateTime dataTo, bool showMulti)
        {
            int rndWait = rnd.Next(0, 2);
            await Task.Delay(rndWait);
            // setup parametri costanti
            string source = "DB";
            Stopwatch sw = new Stopwatch();
            sw.Start();
            List<RegistroControlliModel>? result = new List<RegistroControlliModel>();
            // cerco in _redisConn...
            string currKey = $"{redisBaseKey}:RecContr:{idxMacchina}:{idxODL}:{dataFrom:yyyyyMMdd-HHmm}:{dataFrom:yyyyyMMdd-HHmm}:{showMulti}";
#if false
            RedisValue rawData = redisDb.StringGet(currKey);
#endif
            RedisValue rawData = await _redisDb.StringGetAsync(currKey);
            if (rawData.HasValue)
            {
                result = JsonConvert.DeserializeObject<List<RegistroControlliModel>>($"{rawData}");
                source = "REDIS";
            }
            else
            {
                result = dbTabController.RegControlliFilt(idxMacchina, idxODL, dataFrom, dataTo, showMulti);
                // serializzo e salvo...
                rawData = JsonConvert.SerializeObject(result);
#if false
                redisDb.StringSet(currKey, rawData, UltraLongCache);
#endif
                await _redisDb.StringSetAsync(currKey, rawData, UltraLongCache);
            }
            if (result == null)
            {
                result = new List<RegistroControlliModel>();
            }
            sw.Stop();
#if false
            Log.Debug($"RegControlliFiltAsync | {source} | {sw.Elapsed.TotalMilliseconds}ms");
#endif
            string callName = $"RegControlliFiltAsync.{source}";
            int numRec = esCollect.RecordCall(callName, sw.Elapsed.TotalMilliseconds);
            if (numRec >= nRecLog)
            {
                Log.Debug(esCollect.GetCallSum(callName, true));
            }
            return result;
        }

        /// <summary>
        /// Registra controllo
        /// </summary>
        /// <param name="idxMacchina"></param>
        /// <param name="matrOpr"></param>
        /// <param name="esitoOk"></param>
        /// <param name="note"></param>
        /// <param name="dataOra"></param>
        /// <returns></returns>
        public async Task<bool> RegControlliInsert(string idxMacchina, int matrOpr, bool esitoOk, string note, DateTime dataOra)
        {
            bool answ = false;
            try
            {
                // inserisco evento
                answ = dbTabController.RegControlliInsert(idxMacchina, matrOpr, esitoOk, note, dataOra);
                await FlushCache("RecContr");
            }
            catch (Exception exc)
            {
                string logMsg = $"Eccezione in RegControlliInsertAsync | macchina: {idxMacchina} | DataOra: {dataOra} | MatrOpr: {matrOpr} | Qta {esitoOk} | Note: {note}{Environment.NewLine}{exc}";
                Log.Error(logMsg);
            }
            return answ;
        }

        /// <summary>
        /// Restituisce elenco ULTIMI RC x macchina
        /// </summary>
        /// <param name="idxMacchina"></param>
        /// <returns></returns>
        public async Task<List<RegistroControlliModel>> RegControlliLast(string idxMacchina)
        {
            int rndWait = rnd.Next(0, 2);
            await Task.Delay(rndWait);
            // setup parametri costanti
            string source = "DB";
            Stopwatch sw = new Stopwatch();
            sw.Start();
            List<RegistroControlliModel>? result = new List<RegistroControlliModel>();
            // cerco in _redisConn...
            string currKey = $"{redisBaseKey}:RecContr:{idxMacchina}:LAST";
            RedisValue rawData = _redisDb.StringGet(currKey);
#if false
            RedisValue rawData = await redisDb.StringGetAsync(currKey);
#endif
            if (rawData.HasValue)
            {
                result = JsonConvert.DeserializeObject<List<RegistroControlliModel>>($"{rawData}");
                source = "REDIS";
            }
            else
            {
                result = dbTabController.RegControlliLast(idxMacchina);
                // serializzo e salvo...
                rawData = JsonConvert.SerializeObject(result);
#if false
                await redisDb.StringSetAsync(currKey, rawData, UltraLongCache);
#endif
                _redisDb.StringSet(currKey, rawData, UltraLongCache);
            }
            if (result == null)
            {
                result = new List<RegistroControlliModel>();
            }
            sw.Stop();
#if false
            Log.Debug($"RegControlliLast | {source} | {sw.Elapsed.TotalMilliseconds}ms");
#endif
            string callName = $"RegControlliLast.{source}";
            int numRec = esCollect.RecordCall(callName, sw.Elapsed.TotalMilliseconds);
            if (numRec >= nRecLog)
            {
                Log.Debug(esCollect.GetCallSum(callName, true));
            }
            return result;
        }

        /// <summary>
        /// Aggiunta record RegistroScarti
        /// </summary>
        /// <param name="idxMacchina"></param>
        /// <param name="tagCode"></param>
        /// <param name="matrOpr"></param>
        /// <param name="dataFrom"></param>
        /// <param name="dataTo"></param>
        /// <returns></returns>
        public async Task<List<RegistroDichiarazioniModel>> RegDichiarGetFilt(string idxMacchina, string tagCode, int matrOpr, int idxODL, DateTime dataFrom, DateTime dataTo)
        {
            // setup parametri costanti
            string source = "DB";
            Stopwatch sw = new Stopwatch();
            sw.Start();
            List<RegistroDichiarazioniModel>? result = new List<RegistroDichiarazioniModel>();
            // cerco in _redisConn...
            string currKey = $"{redisBaseKey}:RegDichiar:{idxMacchina}:{tagCode}:{matrOpr}:{idxODL}:{dataFrom:yyyyyMMdd-HHmm}:{dataTo:yyyyyMMdd-HHmm}";
            RedisValue rawData = await _redisDb.StringGetAsync(currKey);
            if (rawData.HasValue)
            {
                result = JsonConvert.DeserializeObject<List<RegistroDichiarazioniModel>>($"{rawData}");
                source = "REDIS";
            }
            else
            {
                result = dbTabController.RegDichiarGetFilt(idxMacchina, tagCode, matrOpr, idxODL, dataFrom, dataTo);
                // serializzo e salvo...
                rawData = JsonConvert.SerializeObject(result);
                await _redisDb.StringSetAsync(currKey, rawData, UltraLongCache);
            }
            if (result == null)
            {
                result = new List<RegistroDichiarazioniModel>();
            }
            sw.Stop();
            Log.Debug($"RegDichiarGetFilt | {source} | {sw.Elapsed.TotalMilliseconds}ms");
            return result;
        }

        /// <summary>
        /// Aggiunta record Registro Dichiarazioni
        /// </summary>
        /// <param name="newRec"></param>
        /// <returns></returns>
        public async Task<bool> RegDichiarInsert(RegistroDichiarazioniModel newRec)
        {
            bool answ = false;
            try
            {
                // inserisco evento
                answ = await dbTabController.RegDichiarInsert(newRec);
                // reset cache eventi/commenti
                await FlushCache("RegDichiar");
            }
            catch (Exception exc)
            {
                string logMsg = $"Eccezione in RegDichiarInsertAsync | macchina: {newRec.IdxMacchina} | DtRec: {newRec.DtRec} | TagCode: {newRec.TagCode} | MatrOpr: {newRec.MatrOpr} | ValString {newRec.ValString}{Environment.NewLine}{exc}";
                Log.Error(logMsg);
            }
            return answ;
        }

        /// <summary>
        /// Aggiunta record Registro Dichiarazioni
        /// </summary>
        /// <param name="newRec"></param>
        /// <returns></returns>
        public async Task<bool> RegDichiarUpdate(RegistroDichiarazioniModel newRec)
        {
            bool answ = false;
            try
            {
                // inserisco evento
                answ = await dbTabController.RegDichiarUpdate(newRec);
                // reset cache eventi/commenti
                await FlushCache("RegDichiar");
            }
            catch (Exception exc)
            {
                string logMsg = $"Eccezione in RegDichiarUpdateAsync | macchina: {newRec.IdxMacchina} | DtRec: {newRec.DtRec} | TagCode: {newRec.TagCode} | MatrOpr: {newRec.MatrOpr} | ValString {newRec.ValString}{Environment.NewLine}{exc}";
                Log.Error(logMsg);
            }
            return answ;
        }

        /// <summary>
        /// Restituisce elenco RS filtrato
        /// </summary>
        /// <param name="idxMacchina"></param>
        /// <param name="idxODL"></param>
        /// <param name="dataFrom"></param>
        /// <param name="dataTo"></param>
        /// <param name="showMulti"></param>
        /// <returns></returns>
        public async Task<List<RegistroScartiModel>> RegScartiGetFilt(string idxMacchina, int idxODL, DateTime dataFrom, DateTime dataTo, bool showMulti)
        {
            // setup parametri costanti
            string source = "DB";
            Stopwatch sw = new Stopwatch();
            sw.Start();
            List<RegistroScartiModel>? result = new List<RegistroScartiModel>();
            // cerco in _redisConn...
            string currKey = $"{redisBaseKey}:RegScarti:{idxMacchina}:{idxODL}:{dataFrom:yyyyyMMdd-HHmm}:{dataTo:yyyyyMMdd-HHmm}:{showMulti}";
            RedisValue rawData = await _redisDb.StringGetAsync(currKey);
            if (rawData.HasValue)
            {
                result = JsonConvert.DeserializeObject<List<RegistroScartiModel>>($"{rawData}");
                source = "REDIS";
            }
            else
            {
                result = dbTabController.RegScartiGetFilt(idxMacchina, idxODL, dataFrom, dataTo, showMulti);
                // serializzo e salvo...
                rawData = JsonConvert.SerializeObject(result);
                await _redisDb.StringSetAsync(currKey, rawData, LongCache);
            }
            if (result == null)
            {
                result = new List<RegistroScartiModel>();
            }
            sw.Stop();
            Log.Debug($"RegScartiGetFilt | {source} | {sw.Elapsed.TotalMilliseconds}ms");
            return result;
        }

        /// <summary>
        /// Aggiunta record RegistroScarti
        /// </summary>
        /// <param name="newRec"></param>
        /// <returns></returns>
        public async Task<bool> RegScartiInsert(RegistroScartiModel newRec)
        {
            bool answ = false;
            try
            {
                // inserisco evento
                answ = dbTabController.RegScartiInsert(newRec);
                // reset cache eventi/commenti
                await FlushCache("RegScarti");
                await FlushCache("RegScartiKit");
            }
            catch (Exception exc)
            {
                string logMsg = $"Eccezione in RegScartiInsertAsync | macchina: {newRec.IdxMacchina} | DataOra: {newRec.DataOra} | Causale: {newRec.Causale} | MatrOpr: {newRec.MatrOpr} | Qta {newRec.Qta} | Note: {newRec.Note}{Environment.NewLine}{exc}";
                Log.Error(logMsg);
            }
            return answ;
        }

        /// <summary>
        /// Elimina elenco RSK da parent
        /// </summary>
        /// <param name="ParentRec"></param>
        /// <returns></returns>
        public async Task<bool> RegScartiKitDelete(RegistroScartiModel ParentRec)
        {
            bool answ = false;
            try
            {
                // inserisco evento
                answ = dbTabController.RegScartiKitDelete(ParentRec);
                // reset cache eventi/commenti
                await FlushCache("RegScarti");
                await FlushCache("RegScartiKit");
            }
            catch (Exception exc)
            {
                string logMsg = $"Eccezione in RegScartiKitDelete | macchina: {ParentRec.IdxMacchina} | DataOra: {ParentRec.DataOra} | Causale: {ParentRec.Causale} | MatrOpr: {ParentRec.MatrOpr} | Qta {ParentRec.Qta} | Note: {ParentRec.Note}{Environment.NewLine}{exc}";
                Log.Error(logMsg);
            }
            return answ;
        }

        /// <summary>
        /// Restituisce elenco RSK filtrato x parent
        /// </summary>
        /// <param name="ParentRec"></param>
        /// <returns></returns>
        public async Task<List<RegistroScartiKitModel>> RegScartiKitGetFilt(RegistroScartiModel ParentRec)
        {
            // setup parametri costanti
            string source = "DB";
            Stopwatch sw = new Stopwatch();
            sw.Start();
            List<RegistroScartiKitModel>? result = new List<RegistroScartiKitModel>();
            // cerco in _redisConn...
            string currKey = $"{redisBaseKey}:RegScartiKit:{ParentRec.IdxMacchina}:{ParentRec.DataOra:yyyyyMMdd-HHmm}:{ParentRec.Causale}";
            RedisValue rawData = await _redisDb.StringGetAsync(currKey);
            if (rawData.HasValue)
            {
                result = JsonConvert.DeserializeObject<List<RegistroScartiKitModel>>($"{rawData}");
                source = "REDIS";
            }
            else
            {
                result = dbTabController.RegScartiKitGetFilt(ParentRec);
                // serializzo e salvo...
                rawData = JsonConvert.SerializeObject(result);
                await _redisDb.StringSetAsync(currKey, rawData, FastCache);
            }
            if (result == null)
            {
                result = new List<RegistroScartiKitModel>();
            }
            sw.Stop();
            Log.Debug($"RegScartiKitGetFilt | {source} | {sw.Elapsed.TotalMilliseconds}ms");
            return result;
        }

        /// <summary>
        /// Split record RegistroScarti --&gt; RegistroScartiKit
        /// </summary>
        /// <param name="newRec"></param>
        /// <returns></returns>
        public async Task<bool> RegScartiKitSplit(RegistroScartiModel newRec)
        {
            bool answ = false;
            try
            {
                // inserisco evento
                answ = await dbTabController.RegScartiKitSplit(newRec);
                // reset cache eventi/commenti
                await FlushCache("RegScarti");
                await FlushCache("RegScartiKit");
            }
            catch (Exception exc)
            {
                string logMsg = $"Eccezione in RegScartiKitSplit | macchina: {newRec.IdxMacchina} | DataOra: {newRec.DataOra} | Causale: {newRec.Causale} | MatrOpr: {newRec.MatrOpr} | Qta {newRec.Qta} | Note: {newRec.Note}{Environment.NewLine}{exc}";
                Log.Error(logMsg);
            }
            return answ;
        }

        /// <summary>
        /// Update qty record singolo articolo di un KIT Scarti
        /// </summary>
        /// <param name="editRec"></param>
        /// <returns></returns>
        public async Task<bool> RegScartiKitUpdateQty(RegistroScartiKitModel editRec)
        {
            bool answ = false;
            try
            {
                // aggiorno record
                answ = dbTabController.RegScartiKitUpdateQty(editRec);
                // reset cache eventi/commenti
                await FlushCache("RegScarti");
                await FlushCache("RegScartiKit");
            }
            catch (Exception exc)
            {
                string logMsg = $"Eccezione in RegScartiKitUpdateQty | macchina: {editRec.IdxMacchina} | DataOra: {editRec.DataOra} | Causale: {editRec.Causale} | MatrOpr: {editRec.MatrOpr} | Qta {editRec.Qta} | Note: {editRec.Note}{Environment.NewLine}{exc}";
                Log.Error(logMsg);
            }
            return answ;
        }

        /// <summary>
        /// Resetta (rileggendo) i dati della macchina
        /// </summary>
        /// <param name="idxMacchina"></param>
        /// <returns></returns>
        public async Task<Dictionary<string, string>> ResetDatiMacchinaAsync(string idxMacchina)
        {
            Dictionary<string, string> answ = new Dictionary<string, string>();

            // verifico il timeout che cambia a seconda che sia vero o falso insEnabled...
            int tOutShort = 0;
            int tOutLong = 0;
            ConfigGetVal("TmOut.MS.S", ref tOutShort);
            ConfigGetVal("TmOut.MS.L", ref tOutLong);
            int redDtMacTOut = tOutLong;

            // inizio con un bel reset...
            string currKey = $"{redisBaseKey}:MSFD";
            await FlushCache(currKey);
            var rigaMSFD = await VMSFDGetByMaccAsync(idxMacchina);
            if (rigaMSFD != null)
            {
                // salvo 1:1 i valori... STATO
                answ.Add("IdxMicroStato", $"{rigaMSFD.IdxMicroStato}");
                answ.Add("IdxStato", $"{rigaMSFD.IdxStato}");
                answ.Add("CodArticolo", $"{rigaMSFD.CodArticolo}");
                answ.Add("insEnabled", $"{rigaMSFD.InsEnabled}");
                answ.Add("sLogEnabled", $"{rigaMSFD.SLogEnabled}");
                answ.Add("pallet", $"{rigaMSFD.Pallet}");
                answ.Add("CodArticolo_A", $"{rigaMSFD.CodArticoloA}");
                answ.Add("CodArticolo_B", $"{rigaMSFD.CodArticoloB}");
                answ.Add("TempoCicloBase", $"{rigaMSFD.TempoCicloBase}");
                answ.Add("PzPalletProd", $"{rigaMSFD.PzPalletProd}");
                answ.Add("MatrOpr", $"{rigaMSFD.MatrOpr}");
                answ.Add("lastVal", $"{rigaMSFD.LastVal}");
                answ.Add("TCBase", $"{rigaMSFD.TempoCicloBase}");

                //...e SETUP
                answ.Add("CodMacc", rigaMSFD.Codmacchina);
                answ.Add("IdxFamIn", $"{rigaMSFD.IdxFamigliaIngresso}");
                answ.Add("Multi", $"{rigaMSFD.Multi}");
                answ.Add("BitFilt", $"{rigaMSFD.BitFilt}");
                answ.Add("MaxVal", $"{rigaMSFD.MaxVal}");
                answ.Add("BSR", $"{rigaMSFD.Bsr}");
                answ.Add("ExplodeBit", $"{rigaMSFD.ExplodeBit}");
                answ.Add("NumBit", $"{rigaMSFD.NumBit}");
                answ.Add("IdxFamMacc", $"{rigaMSFD.IdxFamiglia}");
                answ.Add("simplePallet", $"{rigaMSFD.SimplePallet}");
                answ.Add("palletChange", $"{rigaMSFD.PalletChange}");

                // cerco dati master/slave...
                var macSlave = await Macchine2Slave();
                var mastList = macSlave
                               .Where(x => x.IdxMacchina.Equals(idxMacchina, StringComparison.InvariantCultureIgnoreCase))
                               .ToList();
                var slaveList = macSlave
                               .Where(x => x.IdxMacchinaSlave.Equals(idxMacchina, StringComparison.InvariantCultureIgnoreCase))
                               .ToList();
                string isMaster = mastList.Count > 0 ? "1" : "0";
                string isSlave = slaveList.Count > 0 ? "1" : "0";
                answ.Add("Master", isMaster);
                answ.Add("Slave", isSlave);

                try
                {
                    redDtMacTOut = (answ["insEnabled"].ToLower() == "true") ? tOutShort : tOutLong;
                }
                catch (Exception exc)
                {
                    Log.Info($"Eccezione in calcolo timeout dati macchina: idxMacchina{idxMacchina} | TShort: {tOutShort} | TLong {tOutLong}{Environment.NewLine}{exc}");
                }
                // salvo in _redisConn!
                redisHashDictSet(currKey, answ, TimeSpan.FromSeconds(redDtMacTOut));
            }
            return answ;
        }

        /// <summary>
        /// Reset della cache IO post operazioni come setup ODL...
        /// </summary>
        /// <param name="baseMem">Indirizzo base da cui rimuovere memoria cache</param>
        /// <returns></returns>
        public async Task<bool> ResetIoCache(string baseMem)
        {
            // patterna a partire da cache IO...
            RedisValue pattern = new RedisValue($"{MpIoNS}:*");
            if (!string.IsNullOrEmpty(baseMem))
            {
                pattern = new RedisValue($"{MpIoNS}:{baseMem}:*");
            }
            bool answ = await ExecFlushRedisPatternAsync(pattern);
            return answ;
        }

        /// <summary>
        /// Effettua reset microstato macchina
        /// </summary>
        /// <param name="idxMacchina"></param>
        public async Task resetMicrostatoMacchina(string idxMacchina)
        {
            // salvo microstato 0...
            MicroStatoMacchinaModel newRecMS = new MicroStatoMacchinaModel()
            {
                IdxMacchina = idxMacchina,
                InizioStato = DateTime.Now,
                IdxMicroStato = 0,
                Value = "FER"
            };
            var result = dbTabController.MicroStatoMacchinaUpsert(newRecMS);
            // reset in _redisConn
            await ResetDatiMacchinaAsync(idxMacchina);
        }

        /// <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 async Task<bool> RicalcMse(string idxMacchina, int maxAgeSec)
        {
            bool answ = false;
            answ = dbTabController.RicalcMse(idxMacchina, maxAgeSec);
            await FlushOdlCache();
            await FlushCache(Constants.redisMseKey);
            await FlushCache(Constants.redisMacchine);
            return answ;
        }

        /// <summary>
        /// Esegue il ripristino stato precedente x una macchina che abbia una dichiarazione manuale (es Pausa pranzo) da cui "uscire"
        /// </summary>
        /// <param name="idxMacchina"></param>
        /// <param name="dtCurr"></param>
        /// <param name="valore"></param>
        /// <param name="idxStato"></param>
        /// <param name="matrOpr"></param>
        /// <returns></returns>
        public async Task<bool> RipristinaStatoPrec(string idxMacchina, DateTime dtCurr, string valore, int idxStato = 0, int matrOpr = 0)
        {
            bool inserito = false;
            try
            {
                // inserisco evento
                inserito = await dbTabController.RipristinaStatoPrec(idxMacchina, dtCurr, valore, idxStato, matrOpr);
                // reset cache eventi/commenti
                await FlushCache("EvList");
                await FlushCache("Commenti");
            }
            catch (Exception exc)
            {
                string logMsg = $"Eccezione in fase di RipristinaStatoPrec | macchina: {idxMacchina} | dtCurr: {dtCurr} | valore: {valore} | idxStato {idxStato} | matrOpr {matrOpr}{Environment.NewLine}{exc}";
                Log.Error(logMsg);
            }

            return inserito;
        }

        /// <summary>
        /// Processa registrazione di un counter x una data macchina IOB
        /// </summary>
        /// <param name="idxMacchina"></param>
        /// <param name="counter">contapezzi</param>
        /// <returns></returns>
        public async Task<string> saveCounter(string idxMacchina, string counter)
        {
            // registro conteggio impiego chiamate REDIS
            saveCallRec("saveCounter");
            string answ = "0";
            // inizio processing vero e proprio INPUT...
            if (!string.IsNullOrEmpty(idxMacchina))
            {
                if (!string.IsNullOrEmpty(counter))
                {
                    int newCounter = -1;
                    int.TryParse(counter, out newCounter);
                    // se il conteggio è >= 0 SALVO come nuovo conteggio...
                    if (newCounter >= 0)
                    {
                        string redKey = redHash($"PzCount:{idxMacchina}");
                        // verifico SE ci sia chiave in _redisConn (ALTRIMENTI rileggo da DB)
                        string redVal = _redisDb.StringGet(redKey);
                        if (!string.IsNullOrEmpty(redVal))
                        {
                            // salvo in Redis nell'area corretta il valore richiesto
                            _redisDb.StringSet(redKey, counter);
                            // imposto risposta...
                            answ = counter;
                        }
                        else
                        {
                            // rileggo da DB e salvo e poi restituisco questo...
                            int currCount = await pzCounterTC(idxMacchina);
                            _redisDb.StringSet(redKey, $"{currCount}");
                            // imposto risposta...
                            answ = currCount.ToString();
                        }
                    }
                }
                else
                {
                    string errore = "Errore: parametro counter vuoto";
                    Log.Error(errore);
                    answ = errore;
                }
            }
            else
            {
                string errore = "Errore: parametro macchina vuoto";
                Log.Error(errore);
                answ = errore;
            }
            return answ;
        }

        /// <summary>
        /// Processa registrazione ODL corrente x macchina
        /// </summary>
        /// <param name="idxMacchina"></param>
        /// <param name="currIdxOdl">cod ODL in produzione, se 0 &gt; vuoto</param>
        /// <returns></returns>
        public string saveCurrODL(string idxMacchina, int currIdxOdl)
        {
            // registro conteggio impiego chiamate REDIS
            saveCallRec("saveCurrODL");
            int currOdlCacheDur = 500;
            ConfigGetVal("currOdlCacheDur", ref currOdlCacheDur);
            string answ = "";
            // inizio processing vero e proprio INPUT...
            if (idxMacchina != null)
            {
                if (idxMacchina != "")
                {
                    // se ODL fosse 0 USO DURATA CACHE 1/4...
                    if (currIdxOdl == 0)
                    {
                        currOdlCacheDur = currOdlCacheDur / 4;
                    }
                    _redisDb.StringSet(redHash($"CurrODL:{idxMacchina}"), currIdxOdl, TimeSpan.FromSeconds(currOdlCacheDur));
                    // registro in risposta che è andato tutto bene...
                    answ = "OK";
                }
                else
                {
                    string errore = $"Errore: parametri macchina vuoto (idxMacchina: {idxMacchina} | currIdxOdl: {currIdxOdl})";
                    Log.Error(errore);
                    answ = errore;
                }
            }
            else
            {
                string errore = "Errore: mancano parametri macchina";
                Log.Error(errore);
                answ = errore;
            }
            return answ;
        }

        /// <summary>
        /// Setup oggetto config con lettura da DB
        /// </summary>
        /// <returns></returns>
        public void SetupConfig()
        {
            CurrConfig = ConfigGetAll();
        }

        /// <summary>
        /// Restituisce elenco gruppi Scheda tecnica
        /// </summary>
        /// <returns></returns>
        public async Task<List<ST_AnagGruppi>> ST_AnagGruppiList()
        {
            // setup parametri costanti
            string source = "DB";
            Stopwatch sw = new Stopwatch();
            sw.Start();
            List<ST_AnagGruppi>? result = new List<ST_AnagGruppi>();
            // cerco in _redisConn...
            string currKey = $"{redisBaseKey}:ST:AnagGruppiModel";
            RedisValue rawData = await _redisDb.StringGetAsync(currKey);
            if (rawData.HasValue)
            {
                result = JsonConvert.DeserializeObject<List<ST_AnagGruppi>>($"{rawData}");
                source = "REDIS";
            }
            else
            {
                result = dbTabController.ST_AnagGruppiList();
                // serializzo e salvo...
                rawData = JsonConvert.SerializeObject(result);
                await _redisDb.StringSetAsync(currKey, rawData, UltraLongCache);
            }
            if (result == null)
            {
                result = new List<ST_AnagGruppi>();
            }
            sw.Stop();
            Log.Debug($"ST_AnagGruppiList | {source} | {sw.Elapsed.TotalMilliseconds}ms");
            return result;
        }

        public async Task<bool> ST_CheckCleanByOdl(int idxOdl)
        {
            bool answ = false;
            try
            {
                // inserisco evento
                answ = dbTabController.ST_CheckCleanByOdl(idxOdl);
                await FlushCache("ST");
            }
            catch (Exception exc)
            {
                string logMsg = $"Eccezione in ST_CheckCleanByOdl | idxOdl: {idxOdl}{Environment.NewLine}{exc}";
                Log.Error(logMsg);
            }
            return answ;
        }

        public async Task<bool> ST_CheckUpsert(int idxOdl, int idxST, int oggetto, int num, string valueRead, string extCode, bool checkOk, string userMod, bool forced)
        {
            bool answ = false;
            try
            {
                // inserisco evento
                answ = dbTabController.ST_CheckUpsert(idxOdl, idxST, oggetto, num, valueRead, extCode, checkOk, userMod, forced);
                await FlushCache("ST");
            }
            catch (Exception exc)
            {
                string logMsg = $"Eccezione in ST_CheckUpsert | idxOdl: {idxOdl}{Environment.NewLine}{exc}";
                Log.Error(logMsg);
            }
            return answ;
        }

        /// <summary>
        /// Dati deroga SchedaTecnica serializzati in REDIS
        /// </summary>
        public StCheckOverride ST_DerogaGet(string Utente, int IdxST)
        {
            StCheckOverride answ = new StCheckOverride() { IdxST = 0 };
            string keyDerogaST = redHash($"DerogaSt:{Utente}:{IdxST:000}");
            string rawData = _redisDb.StringGet(keyDerogaST);
            if (!string.IsNullOrEmpty(rawData))
            {
                try
                {
                    answ = JsonConvert.DeserializeObject<StCheckOverride>(rawData);
                }
                catch (Exception exc)
                {
                    Log.Error($"Eccezione in ST_DerogaSet | Utente: {Utente} | IdxST: {IdxST}{Environment.NewLine}{exc}");
                }
            }
            return answ;
        }

        public bool ST_DerogaSet(StCheckOverride deroga)
        {
            bool fatto = false;
            try
            {
                string keyDerogaST = redHash($"DerogaSt:{deroga.Utente}:{deroga.IdxST:000}");
                string rawData = JsonConvert.SerializeObject(deroga);
                _redisDb.StringSet(keyDerogaST, rawData, TimeSpan.FromMinutes(2));
                fatto = true;
            }
            catch (Exception exc)
            {
                Log.Error($"Eccezione in ST_DerogaSet | Utente: {deroga.Utente}  | IdxST: {deroga.IdxST}{Environment.NewLine}{exc}");
            }
            return fatto;
        }

        /// <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 _redisConn...
            string currKey = $"{redisBaseKey}:STAR:{codGruppo}:{idxODL}";
            RedisValue rawData = await _redisDb.StringGetAsync(currKey);
            //if (!string.IsNullOrEmpty($"{rawData}"))
            if (rawData.HasValue)
            {
                result = JsonConvert.DeserializeObject<List<ST_ActRow>>($"{rawData}");
                source = "REDIS";
            }
            else
            {
                result = dbTabController.STAR_byGrpOdl(codGruppo, idxODL);
                // serializzo 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 _redisConn...
            string currKey = $"{redisBaseKey}:STAR:{codGruppo}:{label}:{idxODL}";
            RedisValue rawData = await _redisDb.StringGetAsync(currKey);
            //if (!string.IsNullOrEmpty($"{rawData}"))
            if (rawData.HasValue)
            {
                result = JsonConvert.DeserializeObject<List<ST_ActRow>>($"{rawData}");
                source = "REDIS";
            }
            else
            {
                result = dbTabController.STAR_byGrpOdlLbl(codGruppo, label, idxODL);
                // serializzo 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>
        /// Recupero Righe pending da ODL
        /// </summary>
        /// <param name="idxODL"></param>
        /// <returns></returns>
        public List<ST_ActRow> STAR_pendByOdl(int idxODL)
        {
            // setup parametri costanti
            string source = "DB";
            Stopwatch sw = new Stopwatch();
            sw.Start();
            List<ST_ActRow>? result = new List<ST_ActRow>();
            // cerco in _redisConn...
            string currKey = $"{redisBaseKey}:STAR:Pend:{idxODL}";
            RedisValue rawData = _redisDb.StringGet(currKey);
            if (rawData.HasValue)
            {
                result = JsonConvert.DeserializeObject<List<ST_ActRow>>($"{rawData}");
                source = "REDIS";
            }
            else
            {
                result = dbTabController.STAR_pendByOdl(idxODL);
                // serializzo e salvo...
                rawData = JsonConvert.SerializeObject(result);
                _redisDb.StringSet(currKey, rawData, TimeSpan.FromSeconds(5));
            }
            if (result == null)
            {
                result = new List<ST_ActRow>();
            }
            sw.Stop();
            Log.Debug($"STAR_pendByOdl | {source} | {sw.Elapsed.TotalMilliseconds}ms");
            return result;
        }

        /// <summary>
        /// Stato macchina
        /// </summary>
        /// <param name="idxMacchina"></param>
        /// <returns></returns>
        public StatoMacchineModel StatoMacchina(string idxMacchina)
        {
            // setup parametri costanti
            string source = "DB";
            Stopwatch sw = new Stopwatch();
            sw.Start();
            StatoMacchineModel? result = new StatoMacchineModel();
            // cerco in _redisConn...
            string currKey = $"{redisBaseKey}:StatoMacc:{idxMacchina}";
            RedisValue rawData = _redisDb.StringGet(currKey);
            if (rawData.HasValue)
            {
                result = JsonConvert.DeserializeObject<StatoMacchineModel>($"{rawData}");
                source = "REDIS";
            }
            else
            {
                result = dbTabController.StatoMacchina(idxMacchina);
                // serializzo e salvo...
                rawData = JsonConvert.SerializeObject(result);
                _redisDb.StringSet(currKey, rawData, TimeSpan.FromSeconds(2));
            }
            if (result == null)
            {
                result = new StatoMacchineModel();
            }
            sw.Stop();
            Log.Debug($"StatoMacchina | {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> StatoProdMacchinaAsync(string idxMacchina, DateTime dtReq)
        {
            int rndWait = rnd.Next(0, 2);
            await Task.Delay(rndWait);
            // setup parametri costanti
            string source = "DB";
            Stopwatch sw = new Stopwatch();
            sw.Start();
            StatoProdModel? result = new StatoProdModel();
            // cerco in _redisConn...
            string currKey = $"{redisBaseKey}:StatoProd:{idxMacchina}:{dtReq:HHmm}";
            RedisValue rawData = await _redisDb.StringGetAsync(currKey);
            //if (!string.IsNullOrEmpty($"{rawData}"))
            if (rawData.HasValue)
            {
                result = JsonConvert.DeserializeObject<StatoProdModel>($"{rawData}");
                source = "REDIS";
            }
            else
            {
                result = dbTabController.StatoProdMacchina(idxMacchina, dtReq);
                // serializzo e salvo...
                rawData = JsonConvert.SerializeObject(result);
                await _redisDb.StringSetAsync(currKey, rawData, UltraFastCache);
            }
            if (result == null)
            {
                result = new StatoProdModel();
            }
            sw.Stop();
            string callName = $"StatoProdMacchinaAsync.{source}";
            int numRec = esCollect.RecordCall(callName, sw.Elapsed.TotalMilliseconds);
            if (numRec >= nRecLog || true)
            {
                Log.Debug(esCollect.GetCallSum(callName, true));
            }
            return result;
        }

        /// <summary>
        /// Elenco Template KIT da ricerca
        /// </summary>
        /// <param name="codParent"></param>
        /// <param name="codChild"></param>
        /// <returns></returns>
        public List<TemplateKitModel> TemplateKitFilt(string codParent, string codChild)
        {
            string source = "DB";
            Stopwatch sw = new Stopwatch();
            sw.Start();
            List<TemplateKitModel>? result = new List<TemplateKitModel>();
            // cerco in _redisConn...
            string currKey = $"{MP.Core.Utils.redisKitTempl}:{codParent}:{codChild}";
            RedisValue rawData = _redisDb.StringGet(currKey);
            if (rawData.HasValue)
            {
                result = JsonConvert.DeserializeObject<List<TemplateKitModel>>($"{rawData}");
                source = "REDIS";
            }
            else
            {
                result = dbTabController.TemplateKitFilt(codParent, codChild);
                // serializzo e salvo...
                rawData = JsonConvert.SerializeObject(result);
                _redisDb.StringSet(currKey, rawData, LongCache);
            }
            if (result == null)
            {
                result = new List<TemplateKitModel>();
            }
            sw.Stop();
            Log.Debug($"TemplateKitFilt | {source} | {sw.Elapsed.TotalMilliseconds}ms");
            return result;
        }

        /// <summary>
        /// Turno macchina
        /// </summary>
        /// <returns></returns>
        public async Task<TurniMaccModel> TurnoMacchinaGet(string idxMacchina)
        {
            string source = "DB";
            Stopwatch sw = new Stopwatch();
            sw.Start();
            TurniMaccModel? result = new TurniMaccModel();
            // cerco in _redisConn...
            string currKey = $"{redisBaseKey}:TurniMacc:{idxMacchina}";
            RedisValue rawData = await _redisDb.StringGetAsync(currKey);
            //if (!string.IsNullOrEmpty($"{rawData}"))
            if (rawData.HasValue)
            {
                result = JsonConvert.DeserializeObject<TurniMaccModel>($"{rawData}");
                source = "REDIS";
            }
            else
            {
                result = await Task.FromResult(dbTabController.TurnoMacchinaGet(idxMacchina));
                // serializzo e salvo...
                rawData = JsonConvert.SerializeObject(result);
                await _redisDb.StringSetAsync(currKey, rawData, LongCache);
            }
            if (result == null)
            {
                result = new TurniMaccModel();
            }
            sw.Stop();
            Log.Debug($"TurnoMacchinaGet | {source} | {sw.Elapsed.TotalMilliseconds}ms");
            return result;
        }

        /// <summary>
        /// Elenco turni macchina (all)
        /// </summary>
        /// <returns></returns>
        public async Task<List<TurniMaccModel>> TurnoMacchinaGetAll()
        {
            string source = "DB";
            Stopwatch sw = new Stopwatch();
            sw.Start();
            List<TurniMaccModel>? result = new List<TurniMaccModel>();
            // cerco in _redisConn...
            string currKey = $"{redisBaseKey}:TurniMacc:All";
            RedisValue rawData = await _redisDb.StringGetAsync(currKey);
            if (rawData.HasValue)
            {
                result = JsonConvert.DeserializeObject<List<TurniMaccModel>>($"{rawData}");
                source = "REDIS";
            }
            else
            {
                result = await Task.FromResult(dbTabController.TurnoMacchinaGetAll());
                // serializzo e salvo...
                rawData = JsonConvert.SerializeObject(result);
                await _redisDb.StringSetAsync(currKey, rawData, LongCache);
            }
            if (result == null)
            {
                result = new List<TurniMaccModel>();
            }
            sw.Stop();
            Log.Debug($"TurnoMacchinaGetAll | {source} | {sw.Elapsed.TotalMilliseconds}ms");
            return result;
        }

        /// <summary>
        /// Toggle stato turno
        /// </summary>
        /// <param name="idxMacchina"></param>
        /// <param name="numTurno"></param>
        /// <returns></returns>
        public bool TurnoMacchinaToggle(string idxMacchina, int numTurno)
        {
            bool answ = dbTabController.TurnoMacchinaToggle(idxMacchina, numTurno);
            FlushCache("TurniMacc").ConfigureAwait(false);
            return answ;
        }

        /// <summary>
        /// OVERLOAD vecchio nome function per MachineParamUpsert: Effettua UPSERT elenco parametri
        /// correnti x IOB (se c'è UPDATE, se manca ADD)
        /// </summary>
        /// <param name="idxMacchina"></param>
        /// <param name="innovations"></param>
        /// <returns></returns>
        public bool upsertCurrObjItems(string idxMacchina, List<ObjItemDTO> innovations)
        {
            return MachineParamUpsert(idxMacchina, innovations);
        }

        /// <summary>
        /// Intera vista v_MSFD
        /// </summary>
        /// <param name="doForce">forza rilettura + save su _redisConn</param>
        /// <returns></returns>
        public async Task<List<VMSFDModel>> VMSFDGetAll(bool doForce = false)
        {
            // setup parametri costanti
            string source = "DB";
            Stopwatch sw = new Stopwatch();
            sw.Start();
            List<VMSFDModel> result = new List<VMSFDModel>();
            // cerco in _redisConn...
            string currKey = $"{redisBaseKey}:MSFD:ALL";
            RedisValue rawData = await _redisDb.StringGetAsync(currKey);
            if (rawData.HasValue && !doForce)
            {
                result = JsonConvert.DeserializeObject<List<VMSFDModel>>($"{rawData}");
                source = "REDIS";
            }
            else
            {
                result = await dbIocController.VMSFDGetAllAsync();
                // serializzo e salvo...
                rawData = JsonConvert.SerializeObject(result);
                await _redisDb.StringSetAsync(currKey, rawData, UltraFastCache);
            }
            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<VMSFDModel?> VMSFDGetByMaccAsync(string idxMacc)
        {
            // setup parametri costanti
            string source = "DB";
            Stopwatch sw = new Stopwatch();
            sw.Start();
            VMSFDModel? result = null;
            // cerco in _redisConn...
            string currKey = $"{redisBaseKey}:MSFD:MACCH:{idxMacc}";
            RedisValue rawData = await _redisDb.StringGetAsync(currKey);
            //if (!string.IsNullOrEmpty($"{rawData}"))
            if (rawData.HasValue)
            {
                result = JsonConvert.DeserializeObject<VMSFDModel>($"{rawData}");
                source = "REDIS";
            }
            else
            {
                result = await dbIocController.VMSFDGetByMaccAsync(idxMacc);
                // serializzo e salvo...
                rawData = JsonConvert.SerializeObject(result);
                await _redisDb.StringSetAsync(currKey, rawData, UltraFastCache);
            }
            if (result == null)
            {
                result = new();
            }
            sw.Stop();
            Log.Debug($"VMSFDGetByMaccAsync | {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 _redisConn...
            string currKey = $"{redisBaseKey}:MSFD:MULTI:{idxMacc}";
            RedisValue rawData = await _redisDb.StringGetAsync(currKey);
            //if (!string.IsNullOrEmpty($"{rawData}"))
            if (rawData.HasValue)
            {
                result = JsonConvert.DeserializeObject<List<VMSFDModel>>($"{rawData}");
                source = "REDIS";
            }
            else
            {
                result = await dbIocController.VMSFDGetMultiByMaccAsync(idxMacc);
                // serializzo e salvo...
                rawData = JsonConvert.SerializeObject(result);
                await _redisDb.StringSetAsync(currKey, rawData, LongCache);
            }
            if (result == null)
            {
                result = new List<VMSFDModel>();
            }
            sw.Stop();
            Log.Debug($"VMSFDGetMultiByMacc | {source} | {sw.Elapsed.TotalMilliseconds}ms");
            return result;
        }

        public List<VocabolarioModel> VocabolarioGetAll()
        {
            // setup parametri costanti
            string source = "DB";
            Stopwatch sw = new Stopwatch();
            sw.Start();
            List<VocabolarioModel>? result = new List<VocabolarioModel>();
            // cerco in _redisConn...
            string currKey = $"{redisBaseKey}:Vocab";
            RedisValue rawData = _redisDb.StringGet(currKey);
            if (rawData.HasValue)
            {
                result = JsonConvert.DeserializeObject<List<VocabolarioModel>>($"{rawData}");
                source = "REDIS";
            }
            else
            {
                result = dbTabController.VocabolarioGetAll();
                // serializzo e salvo...
                rawData = JsonConvert.SerializeObject(result);
                _redisDb.StringSet(currKey, rawData, UltraLongCache);
            }
            if (result == null)
            {
                result = new List<VocabolarioModel>();
            }
            sw.Stop();
            Log.Debug($"VocabolarioGetAll | {source} | {sw.Elapsed.TotalMilliseconds}ms");
            return result;
        }

        /// <summary>
        /// Elenco causali scarto
        /// </summary>
        /// <returns></returns>
        public async Task<List<vSelCauScartoModel>> VSCS_getAll()
        {
            string source = "DB";
            Stopwatch sw = new Stopwatch();
            sw.Start();
            List<vSelCauScartoModel>? result = new List<vSelCauScartoModel>();
            // cerco in _redisConn...
            string currKey = $"{redisBaseKey}:VSCS";
            RedisValue rawData = await _redisDb.StringGetAsync(currKey);
            if (rawData.HasValue)
            {
                result = JsonConvert.DeserializeObject<List<vSelCauScartoModel>>($"{rawData}");
                source = "REDIS";
            }
            else
            {
                result = await Task.FromResult(dbTabController.VSCS_getAll());
                // serializzo e salvo...
                rawData = JsonConvert.SerializeObject(result);
                await _redisDb.StringSetAsync(currKey, rawData, LongCache);
            }
            if (result == null)
            {
                result = new List<vSelCauScartoModel>();
            }
            sw.Stop();
            Log.Debug($"VSCS_getAll | {source} | {sw.Elapsed.TotalMilliseconds}ms");
            return result;
        }

        /// <summary>
        /// Elenco ultimi ODL x macchina
        /// </summary>
        /// <param name="idxMacchina">Macchina</param>
        /// <param name="numRec"></param>
        /// <returns></returns>
        public async Task<List<vSelOdlModel>> VSOdlGetLastByMacc(string idxMacchina, int numRec)
        {
            string source = "DB";
            Stopwatch sw = new Stopwatch();
            sw.Start();
            List<vSelOdlModel>? result = new List<vSelOdlModel>();
            // cerco in _redisConn...
            string currKey = $"{redisBaseKey}:VSODL:{idxMacchina}:{numRec}";
            RedisValue rawData = await _redisDb.StringGetAsync(currKey);
            if (rawData.HasValue)
            {
                result = JsonConvert.DeserializeObject<List<vSelOdlModel>>($"{rawData}");
                source = "REDIS";
            }
            else
            {
                result = await Task.FromResult(dbTabController.VSOdlGetLastByMacc(idxMacchina, numRec));
                // serializzo e salvo...
                rawData = JsonConvert.SerializeObject(result);
                await _redisDb.StringSetAsync(currKey, rawData, LongCache);
            }
            if (result == null)
            {
                result = new List<vSelOdlModel>();
            }
            sw.Stop();
            Log.Debug($"VSOdlGetLastByMacc | {source} | {sw.Elapsed.TotalMilliseconds}ms");
            return result;
        }

        /// <summary>
        /// Elenco prossimi ODL/PODL x macchina
        /// </summary>
        /// <param name="idxMacchina">Macchina</param>
        /// <param name="showAll"></param>
        /// <param name="numDayAdd"></param>
        /// <returns></returns>
        public async Task<List<vSelOdlModel>> VSOdlGetUnused(string idxMacchina, bool showAll, int numDayAdd)
        {
            string source = "DB";
            Stopwatch sw = new Stopwatch();
            sw.Start();
            List<vSelOdlModel>? result = new List<vSelOdlModel>();
            // cerco in _redisConn...
            string currKey = $"{redisBaseKey}:VSODL:{idxMacchina}:ALL_{showAll}:{numDayAdd}";
            RedisValue rawData = await _redisDb.StringGetAsync(currKey);
            if (rawData.HasValue && rawData.Length() > 2)
            {
                result = JsonConvert.DeserializeObject<List<vSelOdlModel>>($"{rawData}");
                source = "REDIS";
            }
            else
            {
                result = await Task.FromResult(dbTabController.VSOdlGetUnused(idxMacchina, showAll, numDayAdd));
                // serializzo e salvo...
                rawData = JsonConvert.SerializeObject(result);
                await _redisDb.StringSetAsync(currKey, rawData, FastCache);
            }
            if (result == null)
            {
                result = new List<vSelOdlModel>();
            }
            sw.Stop();
            Log.Debug($"VSOdlGetUnused | {source} | {sw.Elapsed.TotalMilliseconds}ms");
            return result;
        }

        #endregion Public Methods

        #region Protected Fields

        protected int expMinutes = 1;

        #endregion Protected Fields

        #region Protected Properties

        /// <summary>
        /// Durata cache data dal valore in config
        /// </summary>
        protected TimeSpan ConfigCache
        {
            get => TimeSpan.FromMinutes(expMinutes);
        }

        #endregion Protected Properties

        #region Protected Methods

        protected override void Dispose(bool disposing)
        {
            if (!_disposed)
            {
                if (disposing)
                {
                    // Free managed resources here
                    dbTabController.Dispose();
                    //dbIocController.Dispose();
                    dbInveController.Dispose();
                    CurrConfig.Clear();
                    connStrParams.Clear();
                    esCollect.Dispose();
                }

                // Free unmanaged resources here
                _disposed = true;
            }

            // Call base class implementation.
            base.Dispose(disposing);
        }

        protected void setExpDays()
        {
            ConfigGetVal("TAB_dtTimerScadLogin", ref expMinutes);
        }

        #endregion Protected Methods

        #region Private Fields

        private static Logger Log = LogManager.GetCurrentClassLogger();
        private bool _disposed = false;
        private string CodModulo = "";

        private string CodModuloParam = "";

        private string ConnStr = "";

        private Dictionary<string, string> connStrParams = new Dictionary<string, string>();

        private string DataBase = "";

        private string DataSource = "";

        /// <summary>
        /// gestore collezione statistiche esecuzione x logging
        /// </summary>
        private ExecStatsCollector esCollect = new ExecStatsCollector();

        /// <summary>
        /// numero minimo di record per cui iniziare fase di log
        /// </summary>
        private int nRecLog = 10;

        private string redisBaseKey = "MP:TAB:Cache";

        private string redisUserDataKey = "MP:TAB:Users";

        /// <summary>
        /// Generatore random classe
        /// </summary>
        private Random rnd = new Random();

        #endregion Private Fields

        #region Private Properties

        private static Controllers.MpInveController dbInveController { get; set; } = null!;

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

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

        #endregion Private Properties

        #region Private Methods

        /// <summary>
        /// Esegue flush memoria _redisConn dato pat2Flush, metodo sincrono
        /// </summary>
        /// <param name="pat2Flush"></param>
        /// <returns></returns>
        private bool ExecFlushRedisPattern(RedisValue pat2Flush)
        {
            bool answ = false;
            var masterEndpoint = _redisConn.GetEndPoints()
                                           .Where(ep => _redisConn.GetServer(ep).IsConnected && !_redisConn.GetServer(ep).IsReplica)
                                           .FirstOrDefault();

            // sepattern è "*" elimino intero DB...
            if (masterEndpoint != null && (pat2Flush.Equals(new RedisValue("*")) || pat2Flush == RedisValue.Null))
            {
                _redisConn.GetServer(masterEndpoint).FlushDatabase(database: _redisDb.Database);
            }
            else
            {
                var server = _redisConn.GetServer(masterEndpoint);
                var keys = server.Keys(database: _redisDb.Database, pattern: pat2Flush, pageSize: 1000);
                var batch = new List<RedisKey>();
                foreach (var key in keys)
                {
                    batch.Add(key);

                    // Flush in batches of 1000
                    if (batch.Count >= 1000)
                    {
                        foreach (var item in batch)
                            _redisDb.KeyDelete(item);

                        batch.Clear();
                    }
                }

                // Flush remaining keys
                foreach (var item in batch)
                    _redisDb.KeyDelete(item);
            }
            answ = true;
#if 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)
                    {
                        redisDb.KeyDelete(item);
                    }
                    answ = true;
                }
            }
#endif
            // notifico update ai client in ascolto x reset cache
            NotifyReloadRequest($"FlushRedisCache | {pat2Flush}");
            return answ;
        }

        /// <summary>
        /// Esegue flush memoria _redisConn dato pat2Flush in async
        /// </summary>
        /// <param name="pat2Flush"></param>
        /// <returns></returns>
        private async Task<bool> ExecFlushRedisPatternAsync(RedisValue pat2Flush)
        {
            bool answ = false;
            var masterEndpoint = _redisConn.GetEndPoints()
                                            .Where(ep => _redisConn.GetServer(ep).IsConnected && !_redisConn.GetServer(ep).IsReplica)
                                            .FirstOrDefault();

            // se pattern è "*" elimino intero DB...
            if (masterEndpoint != null && (pat2Flush.Equals(new RedisValue("*")) || pat2Flush == RedisValue.Null))
            {
                _redisConn.GetServer(masterEndpoint).FlushDatabase(database: _redisDb.Database);
            }
            else
            {
                var server = _redisConn.GetServer(masterEndpoint);
                var keys = server.Keys(database: _redisDb.Database, pattern: pat2Flush, pageSize: 1000);

                var deleteTasks = new List<Task>();
                foreach (var key in keys)
                {
                    deleteTasks.Add(_redisDb.KeyDeleteAsync(key));
                    if (deleteTasks.Count >= 1000)
                    {
                        await Task.WhenAll(deleteTasks);
                        deleteTasks.Clear();
                    }
                }
                if (deleteTasks.Count > 0)
                {
                    await Task.WhenAll(deleteTasks);
                }
            }
            answ = true;
#if 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, pat2Flush);
                    foreach (var item in keyList)
                    {
                        await redisDb.KeyDeleteAsync(item);
                    }
                    answ = true;
                }
            }
#endif
            // notifico update ai client in ascolto x reset cache
            NotifyReloadRequest($"FlushRedisCache | {pat2Flush}");
            return answ;
        }

        /// <summary>
        /// Hash dati EXE TASK x la macchina specificata
        /// </summary>
        /// <param name="idxMacchina"></param>
        /// <returns></returns>
        private string exeTaskHash(string idxMacchina)
        {
            return RedHashMpIO($"ExeTask:{idxMacchina}");
        }

        /// <summary>
        /// Restitusice elenco KVP dei TASK (da passare a IOB-WIN) per l'impianto indicato
        /// </summary>
        /// <param name="idxMacchina"></param>
        /// <returns></returns>
        private Dictionary<string, string> mTaskMacchina(string idxMacchina)
        {
            // hard coded dimensione vettore DatiMacchine
            Dictionary<string, string> answ = new Dictionary<string, string>();
            // ORA recupero da memoria _redisConn...
            try
            {
                var currKey = (RedisKey)exeTaskHash(idxMacchina);
                answ = redisHashDictGet(currKey);
            }
            catch (Exception exc)
            {
                Log.Info(string.Format("Errore in recupero dati EXE TASK x Redis mTaskMacchina - idxMacchina {2}:{0}{1}", Environment.NewLine, exc, idxMacchina));
            }
            return answ;
        }

        private string redHash(string keyName)
        {
            string result = keyName;
            try
            {
                result = $"{CodModulo}:{DataSource}:{DataBase}:{keyName}".Replace("\\", "_");
            }
            catch (Exception exc)
            {
                Log.Error($"Errore in redHash{Environment.NewLine}{exc}");
            }

            return result;
        }

#if false
        protected string RedHashMpIO(string keyName)
        {
            string result = keyName;
            try
            {
                result = $"{MpIoNS}:{keyName}".Replace("\\", "_");
            }
            catch (Exception exc)
            {
                Log.Error($"Errore in RedHashMpIO{Environment.NewLine}{exc}");
            }

            return result;
        }
#endif

        private string redHashParam(string keyName)
        {
            string result = keyName;
            try
            {
                result = $"{CodModuloParam}:{DataSource}:{DataBase}:{keyName}".Replace("\\", "_");
            }
            catch (Exception exc)
            {
                Log.Error($"Errore in redHashParam{Environment.NewLine}{exc}");
            }

            return result;
        }

        /// <summary>
        /// Recupero HashSet _redisConn come Dictionary
        /// </summary>
        /// <param name="currKey"></param>
        /// <param name="dict"></param>
        private Dictionary<string, string> redisHashDictGet(RedisKey currKey)
        {
            Dictionary<string, string> answ = new Dictionary<string, string>();
            try
            {
                answ = _redisDb
                            .HashGetAll(currKey)
                            .ToDictionary(x => $"{x.Name}", x => $"{x.Value}");
            }
            catch (Exception exc)
            {
                Log.Info($"Errore redisHashDictGet | currKey: {currKey}{Environment.NewLine}{exc}");
            }
            return answ;
        }

        /// <summary>
        /// Salvataggio Dictionary come HashSet Redis
        /// </summary>
        /// <param name="currKey"></param>
        /// <param name="dict"></param>
        private bool redisHashDictSet(RedisKey currKey, Dictionary<string, string> dict)
        {
            bool fatto = false;
            try
            {
                HashEntry[] data2ins = new HashEntry[dict.Count];
                int i = 0;
                foreach (KeyValuePair<string, string> kvp in dict)
                {
                    data2ins[i] = new HashEntry(kvp.Key, kvp.Value);
                    i++;
                }
                // salvo!
                _redisDb.HashSet(currKey, data2ins);
                fatto = true;
            }
            catch (Exception exc)
            {
                Log.Error($"Eccezione in redisHashDictSet | currKey: {currKey}{Environment.NewLine}{exc}");
            }
            return fatto;
        }

        /// <summary>
        /// Salvataggio Dictionary come HashSet Redis
        /// </summary>
        /// <param name="currKey"></param>
        /// <param name="dict"></param>
        /// <param name="ttl"></param>
        private bool redisHashDictSet(RedisKey currKey, Dictionary<string, string> dict, TimeSpan ttl)
        {
            bool fatto = false;
            try
            {
                HashEntry[] data2ins = new HashEntry[dict.Count];
                int i = 0;
                foreach (KeyValuePair<string, string> kvp in dict)
                {
                    data2ins[i] = new HashEntry(kvp.Key, kvp.Value);
                    i++;
                }
                // salvo!
                _redisDb.HashSet(currKey, data2ins);
                _redisDb.KeyExpire(currKey, ttl);
                fatto = true;
            }
            catch (Exception exc)
            {
                Log.Error($"Eccezione in redisHashDictSet | currKey: {currKey}{Environment.NewLine}{exc}");
            }
            return fatto;
        }

        /// <summary>
        /// registra su REDIS eventuale superamento numero limite di call x il metodo in oggetto
        /// </summary>
        /// <param name="callCountKey"></param>
        private void saveCallRec(string callCountKey)
        {
            // conto la richiesta nel contatore REDIS
            long nCall = _redisDb.StringIncrement(redHash($"COUNT:pCall:{callCountKey}"));
            //... se == nCall2Log scrivo su log e resetto
            int nCall2Log = 10;
            ConfigGetVal("nCall2Log", ref nCall2Log);

            if (nCall >= nCall2Log)
            {
                // loggo
                Log.Info($"{callCountKey}: {nCall} call received");
                // resetto!
                _redisDb.StringSet(redHash($"COUNT:pCall:{callCountKey}"), "0");
            }
        }

        /// <summary>
        /// Hash dati SAVED (EXE) TASK x la macchina specificata x poter ripristinare in caso di
        /// perdita valore WRITE
        /// </summary>
        /// <param name="idxMacchina"></param>
        /// <returns></returns>
        private string savedTaskHash(string idxMacchina)
        {
            return RedHashMpIO($"SavedTask:{idxMacchina}");
        }

        #endregion Private Methods
    }
}