gpw_next/GPW.CORE.Data/Services/GpwDataService.cs

using EgwCoreLib.Utils;
using GPW.CORE.Data.DbModels;
using GPW.CORE.Data.DTO;
using Microsoft.AspNetCore.Identity.UI.Services;
using Microsoft.EntityFrameworkCore.Update;
using Microsoft.Extensions.Configuration;
using Newtonsoft.Json;
using NLog;
using StackExchange.Redis;
using System.Diagnostics;
using System.Text;

namespace GPW.CORE.Data.Services
{
    public class GpwDataService : IDisposable
    {
        #region Public Fields

        public static CORE.Data.Controllers.GPWController dbController = null!;
        public bool VetoInsert = false;

        #endregion Public Fields

        #region Public Constructors

        public GpwDataService(IConfiguration configuration, IConnectionMultiplexer redisConnMult, IEmailSender emailSender)
        {
            _configuration = configuration;
            _emailSender = emailSender;
            // Conf cache
            redisConn = redisConnMult;// ConnectionMultiplexer.Connect(_configuration.GetConnectionString("Redis"));
            //redisConn = ConnectionMultiplexer.Connect(_configuration.GetConnectionString("Redis"));
            redisDb = this.redisConn.GetDatabase();

            // json serializer... FIX errore loop circolare https://www.ryadel.com/en/jsonserializationexception-self-referencing-loop-detected-error-fix-entity-framework-asp-net-core/
            JSSettings = new JsonSerializerSettings()
            {
                ReferenceLoopHandling = ReferenceLoopHandling.Ignore
            };

            // cod app
            CodApp = _configuration.GetValue<string>("CodApp") ?? "GPW";
            var strVeto = _configuration["VetoIns"];
            _ = bool.TryParse(strVeto, out VetoInsert);
            // Conf DB
            string connStr = _configuration.GetConnectionString("GPW.DB") ?? "Server=W2019-SQL-STEAM;Database=GPW; integrated security=True; App=GPW.CORE.WRKLOG; TrustServerCertificate=True;";
            if (string.IsNullOrEmpty(connStr))
            {
                Log.Error("ConnString empty!");
            }
            else
            {
                dbController = new CORE.Data.Controllers.GPWController(configuration);
            }

            // init datapipe...
            mPipeTimb = new MessagePipe(redisConn, Const.rPipeChTimb);
            mPipeRich = new MessagePipe(redisConn, Const.rPipeChRich);

            Log.Info("Avviata classe GpwDataService");
        }

        #endregion Public Constructors

        #region Public Properties

        public string CodApp { get; set; } = "";

        /// <summary>
        /// Pipe messaggi richieste
        /// </summary>
        public MessagePipe mPipeRich { get; set; } = null!;

        /// <summary>
        /// Pipe messaggi timbrature
        /// </summary>
        public MessagePipe mPipeTimb { get; set; } = null!;

        #endregion Public Properties

        #region Public Methods

        /// <summary>
        /// Elenco AKV
        /// </summary>
        public async Task<List<AnagKeyValueModel>?> AKVList()
        {
            string source = "DB";

            List<AnagKeyValueModel>? dbResult = new List<AnagKeyValueModel>();
            // cerco da cache
            string currKey = rKeyAKV;
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            string? rawData = await redisDb.StringGetAsync(currKey);
            if (!string.IsNullOrEmpty(rawData))
            {
                source = "REDIS";
                var tempResult = JsonConvert.DeserializeObject<List<AnagKeyValueModel>>(rawData);
                if (tempResult == null)
                {
                    dbResult = new List<AnagKeyValueModel>();
                }
                else
                {
                    dbResult = tempResult;
                }
            }
            else
            {
                dbResult = dbController.AnagKeyValGetAll();
                rawData = JsonConvert.SerializeObject(dbResult, JSSettings);
                await redisDb.StringSetAsync(currKey, rawData, UltraLongCache);
            }
            if (dbResult == null)
            {
                dbResult = new List<AnagKeyValueModel>();
            }
            stopWatch.Stop();
            TimeSpan ts = stopWatch.Elapsed;
            Log.Debug($"AKVList | {source} in: {ts.TotalMilliseconds} ms");
            return dbResult;
        }

        /// <summary>
        /// Recupera l'elenco fasi (tutte)
        /// </summary>
        /// <returns></returns>
        public async Task<List<AnagClientiModel>> AnagClientiAll()
        {
            string source = "DB";
            List<AnagClientiModel>? dbResult = new List<AnagClientiModel>();
            string currKey = $"{rKeyCliAll}";

            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            string? rawData = await redisDb.StringGetAsync(currKey);
            if (!string.IsNullOrEmpty(rawData))
            {
                source = "REDIS";
                var tempResult = JsonConvert.DeserializeObject<List<AnagClientiModel>>(rawData);
                if (tempResult == null)
                {
                    dbResult = new List<AnagClientiModel>();
                }
                else
                {
                    dbResult = tempResult;
                }
            }
            else
            {
                dbResult = dbController.AnagClientiAll();
                rawData = JsonConvert.SerializeObject(dbResult, JSSettings);
                await redisDb.StringSetAsync(currKey, rawData, LongCache);
            }
            if (dbResult == null)
            {
                dbResult = new List<AnagClientiModel>();
            }
            stopWatch.Stop();
            TimeSpan ts = stopWatch.Elapsed;
            Log.Debug($"AnagClientiAll | {source} in: {ts.TotalMilliseconds} ms");
            return dbResult;
        }

        /// <summary>
        /// Eliminazione record cliente
        /// - se ha progetti associati --&gt; logica (disattiva)
        /// - se non ha progetti elimino record
        /// </summary>
        /// <param name="remItem"></param>
        /// <returns></returns>
        public async Task<bool> AnagClientiDelete(AnagClientiModel remItem)
        {
            bool answ = false;
            try
            {
                answ = dbController.AnagClientiDelete(remItem);
                // invalido la cache...
                await ExecFlushRedisPattern($"{redisBaseAddr}:*");
            }
            catch (Exception exc)
            {
                Log.Error($"Eccezione in AnagClientiDelete{Environment.NewLine}{exc}");
            }
            return answ;
        }

        /// <summary>
        /// Aggiornamento record cliente
        /// </summary>
        /// <param name="currItem"></param>
        /// <returns></returns>
        public async Task<bool> AnagClientiUpsert(AnagClientiModel currItem)
        {
            bool answ = false;
            try
            {
                answ = dbController.AnagClientiUpsert(currItem);
                // invalido la cache...
                await ExecFlushRedisPattern($"{redisBaseAddr}:*");
            }
            catch (Exception exc)
            {
                Log.Error($"Eccezione in AnagClientiUpsert{Environment.NewLine}{exc}");
            }
            return answ;
        }

        /// <summary>
        /// Recupera l'elenco fasi (tutte)
        /// </summary>
        /// <returns></returns>
        public async Task<List<AnagFasiModel>> AnagFasiAll()
        {
            string source = "DB";
            List<AnagFasiModel>? dbResult = new List<AnagFasiModel>();
            string currKey = $"{rKeyFasiAll}";
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            string? rawData = await redisDb.StringGetAsync(currKey);
            if (!string.IsNullOrEmpty(rawData))
            {
                source = "REDIS";
                var tempResult = JsonConvert.DeserializeObject<List<AnagFasiModel>>(rawData);
                if (tempResult == null)
                {
                    dbResult = new List<AnagFasiModel>();
                }
                else
                {
                    dbResult = tempResult;
                }
            }
            else
            {
                dbResult = dbController.AnagFasiAll(false);
                rawData = JsonConvert.SerializeObject(dbResult, JSSettings);
                await redisDb.StringSetAsync(currKey, rawData, LongCache);
            }
            if (dbResult == null)
            {
                dbResult = new List<AnagFasiModel>();
            }
            stopWatch.Stop();
            TimeSpan ts = stopWatch.Elapsed;
            Log.Debug($"AnagFasiAll | {source} in: {ts.TotalMilliseconds} ms");
            return dbResult;
        }

        /// <summary>
        /// Elenco fasi dato ancestor
        /// </summary>
        /// <param name="idxFaseAnc"></param>
        /// <returns></returns>
        public List<AnagFasiModel> AnagFasiByAncestor(int idxFaseAnc)
        {
            string source = "DB";
            List<AnagFasiModel>? dbResult = new List<AnagFasiModel>();
            string currKey = $"{rKeyFasiAnc}:{idxFaseAnc}";
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            string? rawData = redisDb.StringGet(currKey);
            if (!string.IsNullOrEmpty(rawData))
            {
                source = "REDIS";
                var tempResult = JsonConvert.DeserializeObject<List<AnagFasiModel>>(rawData);
                if (tempResult == null)
                {
                    dbResult = new List<AnagFasiModel>();
                }
                else
                {
                    dbResult = tempResult;
                }
            }
            else
            {
                dbResult = dbController.AnagFasiByAncestor(idxFaseAnc);
                rawData = JsonConvert.SerializeObject(dbResult, JSSettings);
                redisDb.StringSet(currKey, rawData, LongCache);
            }
            if (dbResult == null)
            {
                dbResult = new List<AnagFasiModel>();
            }
            stopWatch.Stop();
            TimeSpan ts = stopWatch.Elapsed;
            Log.Debug($"AnagFasiByAncestor | {source} in: {ts.TotalMilliseconds} ms");
            return dbResult;
        }

        /// <summary>
        /// Recupera info x una specifica FASE
        /// </summary>
        /// <returns></returns>
        public async Task<AnagFasiModel?> AnagFasiByKey(int idxFase)
        {
            string source = "DB";
            AnagFasiModel? dbResult = new AnagFasiModel();
            // cerco "secca "in redis...
            string currKey = $"{rKeyFasiSearch}:{idxFase}";
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            string? rawData = await redisDb.StringGetAsync(currKey);
            if (!string.IsNullOrEmpty(rawData))
            {
                source = "REDIS";
                var tempResult = JsonConvert.DeserializeObject<AnagFasiModel>(rawData);
                if (tempResult == null)
                {
                    dbResult = new AnagFasiModel();
                }
                else
                {
                    dbResult = tempResult;
                }
            }
            else
            {
                dbResult = dbController.AnagFasiByKey(idxFase);
                rawData = JsonConvert.SerializeObject(dbResult, JSSettings);
                await redisDb.StringSetAsync(currKey, rawData, UltraLongCache);
            }
            stopWatch.Stop();
            TimeSpan ts = stopWatch.Elapsed;
            Log.Debug($"AnagFasiSearch | {source} in: {ts.TotalMilliseconds} ms");
            return dbResult;
        }

        /// <summary>
        /// Elenco fasi dato progetto
        /// </summary>
        /// <param name="idxProj"></param>
        /// <returns></returns>
        public async Task<List<AnagFasiModel>?> AnagFasiByProj(int idxProj)
        {
            string source = "DB";
            List<AnagFasiModel>? dbResult = new List<AnagFasiModel>();
            // cerco "secca "in redis...
            string currKey = $"{rKeyFasiByProj}:{idxProj}";
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            string? rawData = await redisDb.StringGetAsync(currKey);
            if (!string.IsNullOrEmpty(rawData))
            {
                source = "REDIS";
                var tempResult = JsonConvert.DeserializeObject<List<AnagFasiModel>>(rawData);
                if (tempResult == null)
                {
                    dbResult = new List<AnagFasiModel>();
                }
                else
                {
                    dbResult = tempResult;
                }
            }
            else
            {
                dbResult = dbController.AnagFasiByProj(idxProj);
                rawData = JsonConvert.SerializeObject(dbResult, JSSettings);
                await redisDb.StringSetAsync(currKey, rawData, LongCache);
            }
            if (dbResult == null)
            {
                dbResult = new List<AnagFasiModel>();
            }
            stopWatch.Stop();
            TimeSpan ts = stopWatch.Elapsed;
            Log.Debug($"AnagFasiByProj | {source} in: {ts.TotalMilliseconds} ms");
            return dbResult;
        }

        /// <summary>
        /// Eliminazione record Fase (se NON ancestor)
        /// </summary>
        /// <param name="IdxFase"></param>
        /// <returns></returns>
        public async Task<bool> AnagFasiDelete(int IdxFase)
        {
            bool answ = false;
            try
            {
                answ = dbController.AnagFasiDelete(IdxFase);
                // invalido la cache...
                await ExecFlushRedisPattern($"{redisBaseAddr}:*");
            }
            catch (Exception exc)
            {
                Log.Error($"Eccezione in AnagFasiDelete{Environment.NewLine}{exc}");
            }
            return answ;
        }

        /// <summary>
        /// Elenco fasi dato progetto
        /// </summary>
        /// <param name="idxProj"></param>
        /// <returns></returns>
        public async Task<List<AnagFasiExplModel>?> AnagFasiExplByProj(int idxProj)
        {
            string source = "DB";
            List<AnagFasiExplModel>? dbResult = new List<AnagFasiExplModel>();
            // cerco "secca "in redis...
            string currKey = $"{rKeyFasiByProj}_EXPL:{idxProj}";
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            string? rawData = await redisDb.StringGetAsync(currKey);
            if (!string.IsNullOrEmpty(rawData) && rawData.Length > 2)
            {
                source = "REDIS";
                var tempResult = JsonConvert.DeserializeObject<List<AnagFasiExplModel>>(rawData);
                if (tempResult == null)
                {
                    dbResult = new List<AnagFasiExplModel>();
                }
                else
                {
                    dbResult = tempResult;
                }
            }
            else
            {
                dbResult = dbController.AnagFasiExplByProj(idxProj);
                rawData = JsonConvert.SerializeObject(dbResult, JSSettings);
                await redisDb.StringSetAsync(currKey, rawData, LongCache);
            }
            if (dbResult == null)
            {
                dbResult = new List<AnagFasiExplModel>();
            }
            stopWatch.Stop();
            TimeSpan ts = stopWatch.Elapsed;
            Log.Debug($"AnagFasiExplByProj | {source} in: {ts.TotalMilliseconds} ms");
            return dbResult;
        }

        /// <summary>
        /// Aggiorno tutte le fasi del proj con il tag indicato
        /// </summary>
        /// <param name="idxProj"></param>
        /// <param name="CodTagFase"></param>
        /// <returns></returns>
        public async Task<bool> AnagFasiForceTag(int idxProj, string CodTagFase)
        {
            bool answ = false;
            try
            {
                answ = dbController.AnagFasiForceTag(idxProj, CodTagFase);
                // invalido la cache...
                await ExecFlushRedisPattern($"{redisBaseAddr}:*");
            }
            catch (Exception exc)
            {
                Log.Error($"Eccezione in AnagFasiForceTag{Environment.NewLine}{exc}");
            }
            return answ;
        }

        /// <summary>
        /// Aggiornamento record Fasi
        /// </summary>
        /// <param name="currItem"></param>
        /// <returns></returns>
        public async Task<bool> AnagFasiUpsert(AnagFasiModel currItem)
        {
            bool answ = false;
            try
            {
                answ = dbController.AnagFasiUpsert(currItem);
                // invalido la cache...
                await ExecFlushRedisPattern($"{redisBaseAddr}:*");
            }
            catch (Exception exc)
            {
                Log.Error($"Eccezione in AnagFasiUpsert{Environment.NewLine}{exc}");
            }
            return answ;
        }

        /// <summary>
        /// Elenco Giustificativi
        /// </summary>
        /// <returns></returns>
        public async Task<List<AnagGiustModel>?> AnagGiust()
        {
            string source = "DB";
            List<AnagGiustModel>? dbResult = new List<AnagGiustModel>();
            // cerco "secca "in redis...
            string currKey = $"{rKeyGiust}";
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            string? rawData = await redisDb.StringGetAsync(currKey);
            if (!string.IsNullOrEmpty(rawData))
            {
                source = "REDIS";
                var tempResult = JsonConvert.DeserializeObject<List<AnagGiustModel>>(rawData);
                if (tempResult == null)
                {
                    dbResult = new List<AnagGiustModel>();
                }
                else
                {
                    dbResult = tempResult;
                }
            }
            else
            {
                dbResult = dbController.AnagGiust();
                rawData = JsonConvert.SerializeObject(dbResult, JSSettings);
                await redisDb.StringSetAsync(currKey, rawData, LongCache);
            }
            if (dbResult == null)
            {
                dbResult = new List<AnagGiustModel>();
            }
            stopWatch.Stop();
            TimeSpan ts = stopWatch.Elapsed;
            Log.Debug($"AnagGiust | {source} in: {ts.TotalMilliseconds} ms");
            return dbResult;
        }

        /// <summary>
        /// Elenco gruppi (tutti)
        /// </summary>
        /// <returns></returns>
        public async Task<List<AnagGruppiModel>> AnagGruppiAll()
        {
            string source = "DB";
            List<AnagGruppiModel>? dbResult = new List<AnagGruppiModel>();
            string currKey = $"{rKeyProjAll}";
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            string? rawData = await redisDb.StringGetAsync(currKey);
            if (!string.IsNullOrEmpty(rawData))
            {
                source = "REDIS";
                var tempResult = JsonConvert.DeserializeObject<List<AnagGruppiModel>>(rawData);
                if (tempResult == null)
                {
                    dbResult = new List<AnagGruppiModel>();
                }
                else
                {
                    dbResult = tempResult;
                }
            }
            else
            {
                dbResult = dbController.AnagGruppiAll();
                rawData = JsonConvert.SerializeObject(dbResult, JSSettings);
                await redisDb.StringSetAsync(currKey, rawData, UltraLongCache);
            }
            if (dbResult == null)
            {
                dbResult = new List<AnagGruppiModel>();
            }
            stopWatch.Stop();
            TimeSpan ts = stopWatch.Elapsed;
            Log.Debug($"AnagGruppiAll | {source} in: {ts.TotalMilliseconds} ms");
            return dbResult;
        }

        /// <summary>
        /// Recupera l'elenco gruppi abilitati x il dipendente
        /// </summary>
        /// <param name="idxDipendente"></param>
        /// <returns></returns>
        public async Task<List<AnagGruppiModel>> AnagGruppiUser(int idxDipendente)
        {
            string source = "DB";
            List<AnagGruppiModel>? dbResult = new List<AnagGruppiModel>();
            string currKey = $"{rKeyGrpUser}:{idxDipendente}";
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            string? rawData = await redisDb.StringGetAsync(currKey);
            if (!string.IsNullOrEmpty(rawData))
            {
                source = "REDIS";
                var tempResult = JsonConvert.DeserializeObject<List<AnagGruppiModel>>(rawData);
                if (tempResult == null)
                {
                    dbResult = new List<AnagGruppiModel>();
                }
                else
                {
                    dbResult = tempResult;
                }
            }
            else
            {
                dbResult = dbController.AnagGruppiUser(idxDipendente);
                rawData = JsonConvert.SerializeObject(dbResult, JSSettings);
                await redisDb.StringSetAsync(currKey, rawData, LongCache);
            }
            if (dbResult == null)
            {
                dbResult = new List<AnagGruppiModel>();
            }
            stopWatch.Stop();
            TimeSpan ts = stopWatch.Elapsed;
            Log.Debug($"AnagGruppiUser | {source} in: {ts.TotalMilliseconds} ms");
            return dbResult;
        }

        /// <summary>
        /// Dati orario del dipendente indicato
        /// </summary>
        /// <param name="idxProj"></param>
        /// <returns></returns>
        public async Task<AnagOrariModel> AnagOrarioByDip(int idxDip)
        {
            string source = "DB";
            AnagOrariModel? dbResult = new AnagOrariModel();
            string currKey = $"{rKeyAnOrDip}:{idxDip}";
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            string? rawData = await redisDb.StringGetAsync(currKey);
            if (!string.IsNullOrEmpty(rawData))
            {
                source = "REDIS";
                var tempResult = JsonConvert.DeserializeObject<AnagOrariModel>(rawData);
                if (tempResult == null)
                {
                    dbResult = new AnagOrariModel();
                }
                else
                {
                    dbResult = tempResult;
                }
            }
            else
            {
                dbResult = dbController.AnagOrarioByDip(idxDip);
                rawData = JsonConvert.SerializeObject(dbResult, JSSettings);
                await redisDb.StringSetAsync(currKey, rawData, LongCache);
            }
            if (dbResult == null)
            {
                dbResult = new AnagOrariModel();
            }
            stopWatch.Stop();
            TimeSpan ts = stopWatch.Elapsed;
            Log.Debug($"AnagOrarioByDip | {source} in: {ts.TotalMilliseconds} ms");
            return dbResult;
        }

        /// <summary>
        /// Recupera l'elenco progetti (tutti)
        /// </summary>
        /// <returns></returns>
        public async Task<List<AnagProgettiModel>> AnagProjAll()
        {
            string source = "DB";
            List<AnagProgettiModel>? dbResult = new List<AnagProgettiModel>();
            string currKey = $"{rKeyProjAll}";
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            string? rawData = await redisDb.StringGetAsync(currKey);
            if (!string.IsNullOrEmpty(rawData))
            {
                source = "REDIS";
                var tempResult = JsonConvert.DeserializeObject<List<AnagProgettiModel>>(rawData);
                if (tempResult == null)
                {
                    dbResult = new List<AnagProgettiModel>();
                }
                else
                {
                    dbResult = tempResult;
                }
            }
            else
            {
                dbResult = dbController.AnagProjAll(false);
                rawData = JsonConvert.SerializeObject(dbResult, JSSettings);
                await redisDb.StringSetAsync(currKey, rawData, UltraLongCache);
            }
            if (dbResult == null)
            {
                dbResult = new List<AnagProgettiModel>();
            }
            stopWatch.Stop();
            TimeSpan ts = stopWatch.Elapsed;
            Log.Debug($"AnagProjAll | {source} in: {ts.TotalMilliseconds} ms");
            return dbResult;
        }

        /// <summary>
        /// Recupera record da idx richiesto
        /// </summary>
        /// <returns></returns>
        public AnagProgettiModel AnagProjByKey(int IdxProj)
        {
            string source = "DB";
            AnagProgettiModel dbResult = new AnagProgettiModel();
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            dbResult = dbController.AnagProjByKey(IdxProj);
            stopWatch.Stop();
            TimeSpan ts = stopWatch.Elapsed;
            Log.Debug($"AnagProjByKey | {source} in: {ts.TotalMilliseconds} ms");
            return dbResult;
        }

        /// <summary>
        /// Elenco progetti calcolati con ore avanzamento filtrata
        /// </summary>
        /// <param name="gruppo"></param>
        /// <param name="idxCliente"></param>
        /// <param name="showPrjArch"></param>
        /// <param name="showPrjZeroH"></param>
        /// <param name="showPrjStar"></param>
        /// <returns></returns>
        public async Task<List<CalcOreProgettiModel>> AnagProjCalcFilt(string gruppo, int idxCliente, bool showPrjArch, bool showPrjZeroH, bool showPrjStar)
        {
            string source = "DB";
            List<CalcOreProgettiModel>? dbResult = new List<CalcOreProgettiModel>();
            // converto i 3 bool in un bitmap...
            string bFilt = "AZS_";
            bFilt += showPrjArch ? "1" : "0";
            bFilt += showPrjZeroH ? "1" : "0";
            bFilt += showPrjStar ? "1" : "0";
            string currKey = $"{rKeyProjCalc}:G_{gruppo}:C_{idxCliente}:{bFilt}";
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            string? rawData = await redisDb.StringGetAsync(currKey);
            if (!string.IsNullOrEmpty(rawData))
            {
                source = "REDIS";
                var tempResult = JsonConvert.DeserializeObject<List<CalcOreProgettiModel>>(rawData);
                if (tempResult == null)
                {
                    dbResult = new List<CalcOreProgettiModel>();
                }
                else
                {
                    dbResult = tempResult;
                }
            }
            else
            {
                dbResult = dbController.AnagProjCalcFilt(gruppo, idxCliente, showPrjArch, showPrjZeroH, showPrjStar);
                rawData = JsonConvert.SerializeObject(dbResult, JSSettings);
                await redisDb.StringSetAsync(currKey, rawData, UltraLongCache);
            }
            if (dbResult == null)
            {
                dbResult = new List<CalcOreProgettiModel>();
            }
            stopWatch.Stop();
            TimeSpan ts = stopWatch.Elapsed;
            Log.Debug($"AnagProjCalcFilt | {source} in: {ts.TotalMilliseconds} ms");
            return dbResult;
        }

        /// <summary>
        /// Eliminazione record Progetto
        /// - se ha fasi associati &gt;&gt; logica (disattiva)
        /// - se non ha fasi elimino record
        /// </summary>
        /// <param name="remItem"></param>
        /// <returns></returns>
        public async Task<bool> AnagProjDelete(AnagProgettiModel remItem)
        {
            bool answ = false;
            try
            {
                answ = dbController.AnagProjDelete(remItem);
                // invalido la cache...
                await ExecFlushRedisPattern($"{redisBaseAddr}:*");
            }
            catch (Exception exc)
            {
                Log.Error($"Eccezione in AnagProjDelete{Environment.NewLine}{exc}");
            }
            return answ;
        }

        /// <summary>
        /// Clona record Progetti con stored
        /// </summary>
        /// <param name="IdxProj"></param>
        /// <param name="NewName"></param>
        /// <param name="DoYearSubst"></param>
        /// <returns></returns>
        public async Task<bool> AnagProjDoClone(int IdxProj, string NewName, bool DoYearSubst)
        {
            bool answ = false;
            try
            {
                answ = dbController.AnagProjDoClone(IdxProj, NewName, DoYearSubst);
                // invalido la cache...
                await ExecFlushRedisPattern($"{redisBaseAddr}:*");
            }
            catch (Exception exc)
            {
                Log.Error($"Eccezione in AnagProjDoClone{Environment.NewLine}{exc}");
            }
            return answ;
        }

        /// <summary>
        /// Forza ricalcolo statistiche progetti (ALL)
        /// </summary>
        /// <returns></returns>
        public async Task<bool> AnagProjForceUpdate()
        {
            bool answ = false;
            try
            {
                answ = dbController.AnagProjForceUpdate();
                // invalido la cache...
                await ExecFlushRedisPattern($"{redisBaseAddr}:*");
            }
            catch (Exception exc)
            {
                Log.Error($"Eccezione in AnagProjForceUpdate{Environment.NewLine}{exc}");
            }
            return answ;
        }

        /// <summary>
        /// Recupera info x uno specifico PROJ
        /// </summary>
        /// <returns></returns>
        public async Task<AnagProgettiModel?> AnagProjSearch(int idxProj)
        {
            AnagProgettiModel dbResult = new AnagProgettiModel();
            var rawData = await AnagProjAll();
            if (rawData != null)
            {
                var foundData = rawData.Where(x => x.IdxProgetto == idxProj).FirstOrDefault();
                if (foundData != null)
                {
                    dbResult = foundData;
                }
            }
            return dbResult;
        }

        /// <summary>
        /// Upsert record Progetti x stato attivo e starred
        /// </summary>
        /// <param name="IdxProj"></param>
        /// <param name="Attivo"></param>
        /// <param name="Starred"></param>
        /// <returns></returns>
        public async Task<bool> AnagProjUpdStatus(int IdxProj, bool Attivo, bool Starred)
        {
            bool answ = false;
            try
            {
                answ = dbController.AnagProjUpdStatus(IdxProj, Attivo, Starred);
                // invalido la cache...
                await ExecFlushRedisPattern($"{redisBaseAddr}:*");
            }
            catch (Exception exc)
            {
                Log.Error($"Eccezione in AnagProjUpdStatus{Environment.NewLine}{exc}");
            }
            return answ;
        }

        /// <summary>
        /// Upsert record Progetti
        /// </summary>
        /// <param name="currItem"></param>
        /// <returns></returns>
        public async Task<bool> AnagProjUpsert(AnagProgettiModel currItem)
        {
            bool answ = false;
            try
            {
                answ = dbController.AnagProjUpsert(currItem);
                // invalido la cache...
                await ExecFlushRedisPattern($"{redisBaseAddr}:*");
            }
            catch (Exception exc)
            {
                Log.Error($"Eccezione in AnagProjUpsert{Environment.NewLine}{exc}");
            }
            return answ;
        }

        /// <summary>
        /// Elenco TagFasi
        /// </summary>
        /// <returns></returns>
        public async Task<List<AnagTagModel>> AnagTagAll()
        {
            string source = "DB";
            List<AnagTagModel>? dbResult = new List<AnagTagModel>();
            // cerco "secca "in redis...
            string currKey = $"{rKeyTags}:GEN";
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            string? rawData = await redisDb.StringGetAsync(currKey);
            if (!string.IsNullOrEmpty(rawData) && rawData.Length > 2)
            {
                source = "REDIS";
                var tempResult = JsonConvert.DeserializeObject<List<AnagTagModel>>(rawData);
                if (tempResult == null)
                {
                    dbResult = new List<AnagTagModel>();
                }
                else
                {
                    dbResult = tempResult;
                }
            }
            else
            {
                dbResult = dbController.AnagTagAll();
                rawData = JsonConvert.SerializeObject(dbResult, JSSettings);
                await redisDb.StringSetAsync(currKey, rawData, LongCache);
            }
            if (dbResult == null)
            {
                dbResult = new List<AnagTagModel>();
            }
            stopWatch.Stop();
            TimeSpan ts = stopWatch.Elapsed;
            Log.Debug($"AnagTagAll | {source} in: {ts.TotalMilliseconds} ms");
            return dbResult;
        }

        /// <summary>
        /// Elenco TagFasi
        /// </summary>
        /// <returns></returns>
        public async Task<List<AnagTagFasiModel>> AnagTagFasiAll()
        {
            string source = "DB";
            List<AnagTagFasiModel>? dbResult = new List<AnagTagFasiModel>();
            // cerco "secca "in redis...
            string currKey = $"{rKeyTags}:FASI";
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            string? rawData = await redisDb.StringGetAsync(currKey);
            if (!string.IsNullOrEmpty(rawData) && rawData.Length > 2)
            {
                source = "REDIS";
                var tempResult = JsonConvert.DeserializeObject<List<AnagTagFasiModel>>(rawData);
                if (tempResult == null)
                {
                    dbResult = new List<AnagTagFasiModel>();
                }
                else
                {
                    dbResult = tempResult;
                }
            }
            else
            {
                dbResult = dbController.AnagTagFasiAll();
                rawData = JsonConvert.SerializeObject(dbResult, JSSettings);
                await redisDb.StringSetAsync(currKey, rawData, LongCache);
            }
            if (dbResult == null)
            {
                dbResult = new List<AnagTagFasiModel>();
            }
            stopWatch.Stop();
            TimeSpan ts = stopWatch.Elapsed;
            Log.Debug($"AnagTagFasiAll | {source} in: {ts.TotalMilliseconds} ms");
            return dbResult;
        }

        /// <summary>
        /// Vista dati per FASE (tipicamente master...) con totalizzaizone ore budget/real e stato fase
        /// </summary>
        /// <param name="idxFase"></param>
        /// <returns></returns>
        public async Task<CalcOreFasiModel> CalcOreFase(int idxFase)
        {
            string source = "DB";
            CalcOreFasiModel? dbResult = new CalcOreFasiModel();
            string currKey = $"{rKeyCalcOreFase}:{idxFase}";
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            string? rawData = await redisDb.StringGetAsync(currKey);
            if (!string.IsNullOrEmpty(rawData))
            {
                source = "REDIS";
                var tempResult = JsonConvert.DeserializeObject<CalcOreFasiModel>(rawData);
                if (tempResult == null)
                {
                    dbResult = new CalcOreFasiModel();
                }
                else
                {
                    dbResult = tempResult;
                }
            }
            else
            {
                dbResult = dbController.CalcOreFase(idxFase);
                rawData = JsonConvert.SerializeObject(dbResult, JSSettings);
                await redisDb.StringSetAsync(currKey, rawData, LongCache);
            }
            if (dbResult == null)
            {
                dbResult = new CalcOreFasiModel();
            }
            stopWatch.Stop();
            TimeSpan ts = stopWatch.Elapsed;
            Log.Debug($"CalcOreFase | {source} in: {ts.TotalMilliseconds} ms");
            return dbResult;
        }

        /// <summary>
        /// Vista dati per progetto con totalizzaizone ore budget/real
        /// </summary>
        /// <param name="idxProj"></param>
        /// <returns></returns>
        public async Task<CalcOreProgettiModel> CalcOreProj(int idxProj)
        {
            string source = "DB";
            CalcOreProgettiModel? dbResult = new CalcOreProgettiModel();
            string currKey = $"{rKeyCalcOreProj}:{idxProj}";
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            string? rawData = await redisDb.StringGetAsync(currKey);
            if (!string.IsNullOrEmpty(rawData))
            {
                source = "REDIS";
                var tempResult = JsonConvert.DeserializeObject<CalcOreProgettiModel>(rawData);
                if (tempResult == null)
                {
                    dbResult = new CalcOreProgettiModel();
                }
                else
                {
                    dbResult = tempResult;
                }
            }
            else
            {
                dbResult = dbController.CalcOreProj(idxProj);
                rawData = JsonConvert.SerializeObject(dbResult, JSSettings);
                await redisDb.StringSetAsync(currKey, rawData, LongCache);
            }
            if (dbResult == null)
            {
                dbResult = new CalcOreProgettiModel();
            }
            stopWatch.Stop();
            TimeSpan ts = stopWatch.Elapsed;
            Log.Debug($"CalcOreProj | {source} in: {ts.TotalMilliseconds} ms");
            return dbResult;
        }

        /// <summary>
        /// Lista chiusure aziendali dato periodo
        /// </summary>
        /// <param name="dtStart"></param>
        /// <param name="dtEnd"></param>
        /// <returns></returns>
        public async Task<List<CalFesteFerieModel>> CalFestFeriePeriodo(DateTime dtStart, DateTime dtEnd)
        {
            string source = "DB";
            List<CalFesteFerieModel>? dbResult = new List<CalFesteFerieModel>();
            string currKey = $"{rKeyCalendari}:ClaFestFer:{dtStart:yyyyMMdd}:{dtEnd:yyyyMMdd}";
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            string? rawData = await redisDb.StringGetAsync(currKey);
            if (!string.IsNullOrEmpty(rawData))
            {
                source = "REDIS";
                var tempResult = JsonConvert.DeserializeObject<List<CalFesteFerieModel>>(rawData);
                if (tempResult == null)
                {
                    dbResult = new List<CalFesteFerieModel>();
                }
                else
                {
                    dbResult = tempResult;
                }
            }
            else
            {
                dbResult = dbController.CalFestFeriePeriodo(dtStart, dtEnd);
                rawData = JsonConvert.SerializeObject(dbResult, JSSettings);
                await redisDb.StringSetAsync(currKey, rawData, LongCache);
            }
            if (dbResult == null)
            {
                dbResult = new List<CalFesteFerieModel>();
            }
            stopWatch.Stop();
            TimeSpan ts = stopWatch.Elapsed;
            Log.Debug($"CalFestFeriePeriodo | {source} in: {ts.TotalMilliseconds} ms");
            return dbResult;
        }

        /// <summary>
        /// Recupera l'elenco dei controlli VC19 nel periodo indicato x dipendente
        /// </summary>
        /// <param name="idxDipendente">Dipendente interessato</param>
        /// <param name="dtInizio">Data di riferimento (ultima/corrente)</param>
        /// <param name="dtFine">NUm settimane precedenti da recuperare</param>
        /// <returns></returns>
        public async Task<List<CheckVc19Model>> CheckVC19List(int idxDipendente, DateTime dtInizio, DateTime dtFine)
        {
            string source = "DB";
            List<CheckVc19Model>? dbResult = new List<CheckVc19Model>();
            string currKey = $"{rKeyVC19}:{dtInizio:yyyyMMdd}:{dtFine:yyyMMdd}";
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            string? rawData = await redisDb.StringGetAsync(currKey);
            if (!string.IsNullOrEmpty(rawData))
            {
                source = "REDIS";
                var tempResult = JsonConvert.DeserializeObject<List<CheckVc19Model>>(rawData);
                if (tempResult == null)
                {
                    dbResult = new List<CheckVc19Model>();
                }
                else
                {
                    dbResult = tempResult;
                }
            }
            else
            {
                dbResult = dbController.CheckVC19List(idxDipendente, dtInizio, dtFine);
                rawData = JsonConvert.SerializeObject(dbResult, JSSettings);
                await redisDb.StringSetAsync(currKey, rawData, LongCache);
            }
            if (dbResult == null)
            {
                dbResult = new List<CheckVc19Model>();
            }
            stopWatch.Stop();
            TimeSpan ts = stopWatch.Elapsed;
            Log.Debug($"CheckVC19List | {source} in: {ts.TotalMilliseconds} ms");
            return dbResult;
        }

        /// <summary>
        /// Lista configurazione
        /// </summary>
        /// <param name="dtStart"></param>
        /// <param name="dtEnd"></param>
        /// <returns></returns>
        public async Task<List<ConfigModel>> ConfigGetAll()
        {
            string source = "DB";
            List<ConfigModel>? dbResult = new List<ConfigModel>();
            string currKey = $"{rKeyConfig}:Table";
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            string? rawData = await redisDb.StringGetAsync(currKey);
            if (!string.IsNullOrEmpty(rawData))
            {
                source = "REDIS";
                var tempResult = JsonConvert.DeserializeObject<List<ConfigModel>>(rawData);
                if (tempResult == null)
                {
                    dbResult = new List<ConfigModel>();
                }
                else
                {
                    dbResult = tempResult;
                }
            }
            else
            {
                dbResult = dbController.ConfigGetAll();
                rawData = JsonConvert.SerializeObject(dbResult, JSSettings);
                await redisDb.StringSetAsync(currKey, rawData, UltraLongCache);
            }
            if (dbResult == null)
            {
                dbResult = new List<ConfigModel>();
            }
            stopWatch.Stop();
            TimeSpan ts = stopWatch.Elapsed;
            Log.Debug($"ConfigGetAll | {source} in: {ts.TotalMilliseconds} ms");
            return dbResult;
        }

        /// <summary>
        /// Recupera una singola chaive di config da cache/DB
        /// </summary>
        /// <param name="chiave"></param>
        /// <returns></returns>
        public async Task<ConfigModel?> ConfigGetKey(string chiave)
        {
            string source = "DB";
            // cerco in cache direttamente la chiave... altrimenti da redis/db
            ConfigModel? keyResult = null;
            string currKey = $"{rKeyConfig}:Dict:{chiave}";
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            string? rawData = await redisDb.StringGetAsync(currKey);
            if (!string.IsNullOrEmpty(rawData))
            {
                source = "REDIS";
                var tempResult = JsonConvert.DeserializeObject<ConfigModel>(rawData);
                if (tempResult == null)
                {
                    keyResult = new ConfigModel();
                }
                else
                {
                    keyResult = tempResult;
                }
                keyResult = JsonConvert.DeserializeObject<ConfigModel>(rawData);
            }
            else
            {
                var listConfig = await ConfigGetAll();
                keyResult = listConfig.FirstOrDefault(x => x.chiave == chiave);
                rawData = JsonConvert.SerializeObject(keyResult, JSSettings);
                await redisDb.StringSetAsync(currKey, rawData, UltraLongCache);
            }
            stopWatch.Stop();
            TimeSpan ts = stopWatch.Elapsed;
            Log.Debug($"ConfigGetKey | {chiave} | {source} in: {ts.TotalMilliseconds} ms");
            return await Task.FromResult(keyResult);
        }

        /// <summary>
        /// Recupera l'elenco dei dettaglio giornaliero attività di tutti i dipendenti, dato giorno riferimento
        /// </summary>
        /// <param name="dtRif">Data di riferimento</param>
        /// <returns></returns>
        public async Task<List<DailyDataDTO>> DailyDetailAllDip(DateTime dtRif)
        {
            string source = "DB";
            List<DailyDataDTO>? dbResult = new List<DailyDataDTO>();
            string currKey = $"{rKeyDailyData}:ALL:{dtRif.ToString("yyyy-MM-dd")}";
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            string? rawData = await redisDb.StringGetAsync(currKey);
            if (!string.IsNullOrEmpty(rawData))
            {
                source = "REDIS";
                var tempResult = JsonConvert.DeserializeObject<List<DailyDataDTO>>(rawData);
                if (tempResult == null)
                {
                    dbResult = new List<DailyDataDTO>();
                }
                else
                {
                    dbResult = tempResult;
                }
            }
            else
            {
                dbResult = dbController.DailyDetailAllDip(dtRif);
                rawData = JsonConvert.SerializeObject(dbResult, JSSettings);
                await redisDb.StringSetAsync(currKey, rawData, FastCache);
            }
            if (dbResult == null)
            {
                dbResult = new List<DailyDataDTO>();
            }
            stopWatch.Stop();
            TimeSpan ts = stopWatch.Elapsed;
            Log.Debug($"DailyDetailAllDip | {source} in: {ts.TotalMilliseconds} ms");
            return dbResult;
        }

        /// <summary>
        /// Recupera l'elenco dei dettagli giornalieri attività di un dipendente, dato periodo riferimento
        /// </summary>
        /// <param name="idxDipendente">Dipendente interessato</param>
        /// <param name="dtInizio">Data inizio periodo</param>
        /// <param name="dtFine">Data fine periodo</param>
        /// <returns></returns>
        public async Task<List<DailyDataDTO>> DailyDetails(int idxDipendente, DateTime dtInizio, DateTime dtFine)
        {
            string source = "DB";
            List<DailyDataDTO>? dbResult = new List<DailyDataDTO>();
            string currKey = $"{rKeyDailyData}:{idxDipendente}:{dtInizio.ToString("yyyy-MM-dd")}:{dtFine.ToString("yyyy-MM-dd")}";
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            string? rawData = await redisDb.StringGetAsync(currKey);
            if (!string.IsNullOrEmpty(rawData))
            {
                source = "REDIS";
                var tempResult = JsonConvert.DeserializeObject<List<DailyDataDTO>>(rawData);
                if (tempResult == null)
                {
                    dbResult = new List<DailyDataDTO>();
                }
                else
                {
                    dbResult = tempResult;
                }
            }
            else
            {
                dbResult = dbController.DailyDetails(idxDipendente, dtInizio, dtFine);
                rawData = JsonConvert.SerializeObject(dbResult, JSSettings);
                await redisDb.StringSetAsync(currKey, rawData, FastCache);
            }
            if (dbResult == null)
            {
                dbResult = new List<DailyDataDTO>();
            }
            stopWatch.Stop();
            TimeSpan ts = stopWatch.Elapsed;
            Log.Debug($"DailyDetails | {source} in: {ts.TotalMilliseconds} ms");
            return dbResult;
        }

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

        public async Task<List<DipendentiModel>> DipendentiGetAll()
        {
            string source = "DB";
            List<DipendentiModel>? dbResult = new List<DipendentiModel>();
            string currKey = rKeyDipendenti;
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            string? rawData = await redisDb.StringGetAsync(currKey);
            if (!string.IsNullOrEmpty(rawData))
            {
                source = "REDIS";
                var tempResult = JsonConvert.DeserializeObject<List<DipendentiModel>>(rawData);
                if (tempResult == null)
                {
                    dbResult = new List<DipendentiModel>();
                }
                else
                {
                    dbResult = tempResult;
                }
            }
            else
            {
                dbResult = dbController.DipendentiGetAll();
                rawData = JsonConvert.SerializeObject(dbResult, JSSettings);
                await redisDb.StringSetAsync(currKey, rawData, UltraLongCache);
            }
            if (dbResult == null)
            {
                dbResult = new List<DipendentiModel>();
            }
            stopWatch.Stop();
            TimeSpan ts = stopWatch.Elapsed;
            Log.Debug($"DipendentiGetAll | {source} in: {ts.TotalMilliseconds} ms");
            return dbResult;
        }

        public void Dispose()
        {
            // Clear database controller
            dbController.Dispose();
            GC.Collect();
        }

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

        /// <summary>
        /// Lista Eventi dato periodo (TUTTI!)
        /// </summary>
        /// <param name="dtStart"></param>
        /// <param name="dtEnd"></param>
        /// <returns></returns>
        public async Task<List<EventDTO>> EventListPeriodo(int idxDipendente, DateTime dtStart, DateTime dtEnd)
        {
            string source = "DB";
            List<EventDTO>? SchedEvList = new List<EventDTO>();
            string currKey = $"{rKeyEventListDip}:{idxDipendente}:{dtStart:yyyyMMdd}:{dtEnd:yyyyMMdd}";
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            string? rawData = await redisDb.StringGetAsync(currKey);
            if (!string.IsNullOrEmpty(rawData))
            {
                source = "REDIS";
                var tempResult = JsonConvert.DeserializeObject<List<EventDTO>>(rawData);
                if (tempResult == null)
                {
                    SchedEvList = new List<EventDTO>();
                }
                else
                {
                    SchedEvList = tempResult;
                }
            }
            else
            {
                // recupero le fermate aziendali
                var ListFermateAzienda = await CalFestFeriePeriodo(dtStart, dtEnd);
                if (ListFermateAzienda.Count > 0)
                {
                    // conversione fermate in EvDTO...
                    var evAzienda = ListFermateAzienda.Select(x => new EventDTO
                    {
                        DtStart = x.data,
                        DtEnd = x.data.AddDays(1),
                        CodTipo = x.codGiust,
                        IdxDipendente = 0,
                        Titolo = x.descrizione,
                        Descrizione = x.descrizione,
                        Note = x.descrizione,
                        IsDraggable = false,
                        IsCompany = true,
                        Conf = true,
                        Tooltip = $"{x.codGiust} | {x.descrizione}",
                    }).ToList();
                    SchedEvList.AddRange(evAzienda);
                }

                // recupero e converto le richieste dipendente...
                var ListRichiesteDip = await RegRichiesteGetByDip(0, dtStart, dtEnd);
                if (ListRichiesteDip.Count > 0)
                {
                    // conversione fermate in elenco task x calendario...
                    var evDip = ListRichiesteDip.Select(x => new EventDTO
                    {
                        DtStart = x.DtStart,
                        DtEnd = x.DtEnd,
                        CodTipo = x.CodGiust, //$"{x.CodGiust} | {x.DipNav.Abbrev}",
                        Titolo = x.DipNav.Abbrev,
                        IdxDipendente = x.IdxDipendente,
                        Abbrev = x.DipNav.Abbrev,
                        CognomeNome = $"{x.DipNav.Cognome} {x.DipNav.Nome}",
                        Descrizione = $"{x.CodGiust} | {x.DipNav.Abbrev} | {EventDTO.DateForm(x.CodGiust, x.DtStart)} &rarr; {EventDTO.DateForm(x.CodGiust, x.DtEnd)}",
                        //Descrizione = x.CodGiust == "PERM" ? $"{x.CodGiust} | {x.DipNav.Abbrev} | {x.DtStart:HH:mm}--> {x.DtEnd:HH:mm}" : $"{x.CodGiust} | {x.DipNav.Abbrev} | {x.DtStart:yyyy/MM/dd} -> {x.DtEnd:yyyy/MM/dd}",
                        Note = x.Note,
                        IsDraggable = x.IdxDipendente == idxDipendente && !x.Conf,
                        IsCompany = false,
                        Conf = x.Conf,
                        Tooltip = $"{x.CodGiust} | {x.DipNav.Abbrev} | {EventDTO.DateForm(x.CodGiust, x.DtStart)} &rarr; {EventDTO.DateForm(x.CodGiust, x.DtEnd)}",
                    }).ToList();
                    SchedEvList.AddRange(evDip);
                }

                // recupero e converto le malattie...
                var ListMalattie = await RegMalattieGetByPeriod(dtStart, dtEnd);
                if (ListMalattie.Count > 0)
                {
                    // conversione fermate in elenco task x calendario...
                    var evDip = ListMalattie.Select(x => new EventDTO
                    {
                        DtStart = x.DtInizio,
                        DtEnd = x.DtInizio.AddDays(x.NumGG - 1),
                        CodTipo = "MAL",
                        Titolo = x.DipNav.Abbrev,
                        IdxDipendente = x.IdxDipendente,
                        Abbrev = x.DipNav.Abbrev,
                        CognomeNome = $"{x.DipNav.Cognome} {x.DipNav.Nome}",
                        Descrizione = $"MAL | {x.DipNav.Abbrev} {x.DtInizio:yyyy/MM/dd} -> {x.DtInizio.AddDays(x.NumGG - 1):yyyy/MM/dd}",
                        Note = x.CodCert,
                        IsDraggable = x.IdxDipendente == idxDipendente && !x.Conf,
                        IsCompany = false,
                        Conf = x.Conf,
                        Tooltip = $"MAL | {x.DipNav.Abbrev} {x.DtInizio:yyyy/MM/dd} -> {x.DtInizio.AddDays(x.NumGG - 1):yyyy/MM/dd}"
                    }).ToList();
                    SchedEvList.AddRange(evDip);
                }
                rawData = JsonConvert.SerializeObject(SchedEvList, JSSettings);
                await redisDb.StringSetAsync(currKey, rawData, LongCache);
            }
            if (SchedEvList == null)
            {
                SchedEvList = new List<EventDTO>();
            }
            stopWatch.Stop();
            TimeSpan ts = stopWatch.Elapsed;
            Log.Debug($"EventListPeriodo | {source} in: {ts.TotalMilliseconds} ms");
            return SchedEvList;
        }

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

        /// <summary>
        /// Statistiche ultime settimane
        /// </summary>
        /// <param name="idxDipendente"></param>
        /// <param name="dtRif"></param>
        /// <param name="numWeek"></param>
        /// <returns></returns>
        public async Task<List<WeekStatDTO>> LastWeeks(int idxDipendente, DateTime dtRif, int numWeek)
        {
            string source = "DB";
            List<WeekStatDTO>? dbResult = new List<WeekStatDTO>();
            string currKey = $"{rKeyWeekStats}:{idxDipendente}:{dtRif.ToString("yyyy-MM-dd")}:{numWeek}";
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            string? rawData = await redisDb.StringGetAsync(currKey);
            if (!string.IsNullOrEmpty(rawData))
            {
                source = "REDIS";
                var tempResult = JsonConvert.DeserializeObject<List<WeekStatDTO>>(rawData);
                if (tempResult == null)
                {
                    dbResult = new List<WeekStatDTO>();
                }
                else
                {
                    dbResult = tempResult;
                }
            }
            else
            {
                dbResult = dbController.WeekOverview(idxDipendente, dtRif, numWeek);
                rawData = JsonConvert.SerializeObject(dbResult, JSSettings);
                await redisDb.StringSetAsync(currKey, rawData, LongCache);
            }
            if (dbResult == null)
            {
                dbResult = new List<WeekStatDTO>();
            }
            stopWatch.Stop();
            TimeSpan ts = stopWatch.Elapsed;
            Log.Debug($"LastWeeks | {source} in: {ts.TotalMilliseconds} ms");
            return dbResult;
        }

        /// <summary>
        /// Elenco pareto progetti ordinati da filtro
        /// </summary>
        /// <param name="idxDip"></param>
        /// <param name="numDayPrev"></param>
        /// <param name="maxResult"></param>
        /// <returns></returns>
        public async Task<List<ParetoRegAttModel>> ParetoRegAtt(int idxDip, int numDayPrev, int maxResult)
        {
            string source = "DB";
            DateTime dataFine = DateTime.Today.AddDays(1);
            DateTime dataInizio = dataFine.AddDays(-numDayPrev);
            List<ParetoRegAttModel>? dbResult = new List<ParetoRegAttModel>();
            string currKey = $"{rKeyParetoRegAtt}:{idxDip}:{numDayPrev}:{maxResult}";
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            string? rawData = await redisDb.StringGetAsync(currKey);
            if (!string.IsNullOrEmpty(rawData))
            {
                source = "REDIS";
                var tempResult = JsonConvert.DeserializeObject<List<ParetoRegAttModel>>(rawData);
                if (tempResult == null)
                {
                    dbResult = new List<ParetoRegAttModel>();
                }
                else
                {
                    dbResult = tempResult;
                }
            }
            else
            {
                dbResult = dbController.ParetoRegAtt(idxDip, dataInizio, dataFine, maxResult);
                rawData = JsonConvert.SerializeObject(dbResult, JSSettings);
                await redisDb.StringSetAsync(currKey, rawData, LongCache);
            }
            if (dbResult == null)
            {
                dbResult = new List<ParetoRegAttModel>();
            }
            stopWatch.Stop();
            TimeSpan ts = stopWatch.Elapsed;
            Log.Debug($"ParetoRegAtt | {source} in: {ts.TotalMilliseconds} ms");
            return dbResult;
        }

        /// <summary>
        /// Righe presenze giornaliere
        /// </summary>
        /// <param name="dtRif">DataOra riferimento per richiesta presenze</param>
        /// <returns></returns>
        public async Task<List<StatsDayPresModel>> PresenzeDay(DateTime dtRif)
        {
            string source = "DB";
            List<StatsDayPresModel> dbResult = new List<StatsDayPresModel>();
            string currKey = $"{rKeyStatPresDay}:{dtRif:yyyy-MM-dd}";
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            string? rawData = await redisDb.StringGetAsync(currKey);
            if (!string.IsNullOrEmpty(rawData))
            {
                source = "REDIS";
                var tempResult = JsonConvert.DeserializeObject<List<StatsDayPresModel>>(rawData);
                if (tempResult == null)
                {
                    dbResult = new List<StatsDayPresModel>();
                }
                else
                {
                    dbResult = tempResult;
                }
            }
            else
            {
                dbResult = dbController.PresenzeDay(dtRif);
                rawData = JsonConvert.SerializeObject(dbResult, JSSettings);
                await redisDb.StringSetAsync(currKey, rawData, FastCache);
            }
            if (dbResult == null)
            {
                dbResult = new List<StatsDayPresModel>();
            }
            stopWatch.Stop();
            TimeSpan ts = stopWatch.Elapsed;
            Log.Debug($"PresenzeDay | {source} in: {ts.TotalMilliseconds} ms");
            return dbResult;
        }

        public async Task<bool> RegAttDelete(RegAttivitaModel currItem)
        {
            bool answ = false;
            try
            {
                dbController.RegAttDelete(currItem);
                // invalido la cache...
                await ExecFlushRedisPattern($"{rKeyDailyData}:*");
                await ExecFlushRedisPattern($"{rKeyLastRegAtt}:*");
                await ExecFlushRedisPattern($"{rKeyParetoRegAtt}:*");
                await ExecFlushRedisPattern($"{rKeyWeekStats}:*");
                answ = true;
            }
            catch
            { }
            return answ;
        }

        /// <summary>
        /// Recupera ultima attività dipendente
        /// </summary>
        /// <param name="IdxDipendente"></param>
        /// <param name="onlyActive">cerca ultima solo tra attive (=true) o tutte (=false)</param>
        /// <returns></returns>
        public async Task<RegAttivitaModel> RegAttLastByDip(int IdxDipendente, bool onlyActive)
        {
            await Task.Delay(1);
            RegAttivitaModel dbResult = dbController.RegAttLastByDip(IdxDipendente, onlyActive);
            return dbResult;
        }

        public async Task<bool> RegAttUpdate(RegAttivitaModel currItem)
        {
            bool answ = false;
            try
            {
                dbController.RegAttUpdate(currItem);
                // invalido la cache...
                await ExecFlushRedisPattern($"{rKeyDailyData}:*");
                await ExecFlushRedisPattern($"{rKeyLastRegAtt}:*");
                await ExecFlushRedisPattern($"{rKeyParetoRegAtt}:*");
                await ExecFlushRedisPattern($"{rKeyWeekStats}:*");
                answ = true;
            }
            catch
            { }
            return answ;
        }

        /// <summary>
        /// Effettua eliminazione record registro malattie (SE non confermato)
        /// </summary>
        /// <param name="currItem"></param>
        /// <returns></returns>
        public async Task<bool> RegMalattieDelete(RegMalattieModel currItem)
        {
            bool answ = false;
            try
            {
                answ = dbController.RegMalattieDelete(currItem);
                if (answ)
                {
                    // recupero info dipendente
                    var listDip = await DipendentiGetAll();
                    var currDip = listDip.FirstOrDefault(x => x.IdxDipendente == currItem.IdxDipendente);
                    // gestisco email notifica...
                    string emailDest = _configuration.GetValue<string>("MailDest:InfoMal") ?? "info@egalware.com";
                    if (currDip.idxResp > 0)
                    {
                        string mailResp = await emailResp(currDip.idxResp);
                        if (!string.IsNullOrEmpty(mailResp) && !emailDest.Contains(mailResp))
                        {
                            emailDest += $",{mailResp}";
                        }
                    }
                    string urlRedir = _configuration.GetValue<string>("AdmApp:LinkMal") ?? "";
                    StringBuilder sbMain = new StringBuilder();
                    DateTime adesso = DateTime.Now;
                    sbMain.AppendLine($"Il giorno {adesso:yyyy.MM.dd} alle ore {adesso:HH:mm:ss} è stato <b>rimosso</b> un record di registrazione malattia");
                    sbMain.AppendLine("");
                    sbMain.Append("<div style=\"font-size: 1.3em; color: #CC0066;\">");
                    sbMain.Append($"<b>{currItem.DipNav.Cognome}</b> {currItem.DipNav.Nome} ({currItem.DipNav.Matricola})");
                    //sbMain.Append($"<b>{currDip.Cognome}</b> {currDip.Nome} ({currDip.Matricola})");
                    sbMain.Append("</div>");
                    sbMain.AppendLine("<hr/>");
                    sbMain.AppendLine($"Data Inizio: <b>{currItem.DtInizio}</b>");
                    sbMain.AppendLine($"Numero Giorni: <b>{currItem.NumGG}</b>");
                    sbMain.AppendLine($"Certificato: <b>{currItem.CodCert}</b>");
                    sbMain.AppendLine("<hr/>");
                    sbMain.AppendLine($"Cliccare sul <a href=\"{urlRedir}\">seguente link</a> per accedere alla pagina di gestione");
                    string msgBody = sbMain.ToString();
                    await sendEmail(emailDest, "Eliminazione record Malattia Dipendente", msgBody.Replace($"{Environment.NewLine}", "<br/>"));
                }
                // invalido la cache...
                await ExecFlushRedisPattern($"{rKeyDipendenti}:*");
            }
            catch
            { }
            return answ;
        }

        /// <summary>
        /// Restituisce elenco malattie globali
        /// </summary>
        /// <param name="maxRecord">max record da recuperare</param>
        /// <returns></returns>
        public async Task<List<RegMalattieModel>> RegMalattieGetAll(int maxRecord)
        {
            string source = "DB";
            List<RegMalattieModel>? dbResult = new List<RegMalattieModel>();
            string currKey = $"{rKeyDipendenti}:ALL:RegMalLast:{maxRecord}";
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            string? rawData = await redisDb.StringGetAsync(currKey);
            if (!string.IsNullOrEmpty(rawData))
            {
                source = "REDIS";
                var tempResult = JsonConvert.DeserializeObject<List<RegMalattieModel>>(rawData);
                if (tempResult == null)
                {
                    dbResult = new List<RegMalattieModel>();
                }
                else
                {
                    dbResult = tempResult;
                }
            }
            else
            {
                dbResult = dbController.RegMalattieGetAll(maxRecord);
                rawData = JsonConvert.SerializeObject(dbResult, JSSettings);
                await redisDb.StringSetAsync(currKey, rawData, FastCache);
            }
            if (dbResult == null)
            {
                dbResult = new List<RegMalattieModel>();
            }
            stopWatch.Stop();
            TimeSpan ts = stopWatch.Elapsed;
            Log.Debug($"RegMalattieGetAll | {source} in: {ts.TotalMilliseconds} ms");
            return dbResult;
        }

        /// <summary>
        /// Restituisce elenco malattie dipendente
        /// </summary>
        /// <param name="idxDipendente">Dipendente interessato</param>
        /// <param name="maxRecord">max record da recuperare</param>
        /// <returns></returns>
        public async Task<List<RegMalattieModel>> RegMalattieGetByDip(int idxDipendente, int maxRecord)
        {
            string source = "DB";
            List<RegMalattieModel>? dbResult = new List<RegMalattieModel>();
            string currKey = $"{rKeyDipendenti}:{idxDipendente}:RegMal:{maxRecord}";
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            string? rawData = await redisDb.StringGetAsync(currKey);
            if (!string.IsNullOrEmpty(rawData))
            {
                source = "REDIS";
                var tempResult = JsonConvert.DeserializeObject<List<RegMalattieModel>>(rawData);
                if (tempResult == null)
                {
                    dbResult = new List<RegMalattieModel>();
                }
                else
                {
                    dbResult = tempResult;
                }
            }
            else
            {
                dbResult = dbController.RegMalattieGetByDip(idxDipendente, maxRecord);
                rawData = JsonConvert.SerializeObject(dbResult, JSSettings);
                await redisDb.StringSetAsync(currKey, rawData, FastCache);
            }
            if (dbResult == null)
            {
                dbResult = new List<RegMalattieModel>();
            }
            stopWatch.Stop();
            TimeSpan ts = stopWatch.Elapsed;
            Log.Debug($"RegMalattieGetByDip | {source} in: {ts.TotalMilliseconds} ms");
            return dbResult;
        }

        /// <summary>
        /// Recupera elenco reg malattie dato periodo
        /// </summary>
        /// <param name="DtFrom"></param>
        /// <param name="DtTo"></param>
        /// <returns></returns>
        public async Task<List<RegMalattieModel>> RegMalattieGetByPeriod(DateTime DtFrom, DateTime DtTo)
        {
            string source = "DB";
            List<RegMalattieModel>? dbResult = new List<RegMalattieModel>();
            string currKey = $"{rKeyDipendenti}:ALL:RegMal:{DtFrom:yyyyMMdd}:{DtTo:yyyyMMdd}";
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            string? rawData = await redisDb.StringGetAsync(currKey);
            if (!string.IsNullOrEmpty(rawData))
            {
                source = "REDIS";
                var tempResult = JsonConvert.DeserializeObject<List<RegMalattieModel>>(rawData);
                if (tempResult == null)
                {
                    dbResult = new List<RegMalattieModel>();
                }
                else
                {
                    dbResult = tempResult;
                }
            }
            else
            {
                dbResult = dbController.RegMalattieGetByPeriod(DtFrom, DtTo);
                rawData = JsonConvert.SerializeObject(dbResult, JSSettings);
                await redisDb.StringSetAsync(currKey, rawData, FastCache);
            }
            if (dbResult == null)
            {
                dbResult = new List<RegMalattieModel>();
            }
            stopWatch.Stop();
            TimeSpan ts = stopWatch.Elapsed;
            Log.Debug($"RegMalattieGetByPeriod | {source} in: {ts.TotalMilliseconds} ms");
            return dbResult;
        }

        /// <summary>
        /// Registra o aggiorna record registro malattie
        /// </summary>
        /// <param name="currItem"></param>
        /// <returns></returns>
        public async Task<bool> RegMalattieUpsert(RegMalattieModel currItem)
        {
            bool answ = false;
            try
            {
                // scrivo su DB
                answ = dbController.RegMalattieUpsert(currItem);
                if (answ)
                {
                    // recupero info dipendente
                    var listDip = await DipendentiGetAll();
                    var currDip = listDip.FirstOrDefault(x => x.IdxDipendente == currItem.IdxDipendente);
                    // gestisco email notifica...
                    string emailDest = _configuration.GetValue<string>("MailDest:InfoMal") ?? "info@egalware.com";
                    if (currDip.idxResp > 0)
                    {
                        string mailResp = await emailResp(currDip.idxResp);
                        if (!string.IsNullOrEmpty(mailResp) && !emailDest.Contains(mailResp))
                        {
                            emailDest += $",{mailResp}";
                        }
                    }
                    string urlRedir = _configuration.GetValue<string>("AdmApp:LinkMal") ?? "";
                    StringBuilder sbMain = new StringBuilder();
                    DateTime adesso = DateTime.Now;
                    sbMain.AppendLine($"Il giorno {adesso:yyyy.MM.dd} alle ore {adesso:HH:mm:ss} è stato inserito un nuovo record di registrazione malattia");
                    sbMain.AppendLine("");
                    sbMain.Append("<div style=\"font-size: 1.3em;\">");
                    sbMain.Append($"<b>{currDip.Cognome}</b> {currDip.Nome} ({currDip.Matricola})");
                    sbMain.Append("</div>");
                    sbMain.AppendLine("<hr/>");
                    sbMain.AppendLine($"Data Inizio: <b>{currItem.DtInizio}</b>");
                    sbMain.AppendLine($"Numero Giorni: <b>{currItem.NumGG}</b>");
                    sbMain.AppendLine($"Certificato: <b>{currItem.CodCert}</b>");
                    sbMain.AppendLine("<hr/>");
                    sbMain.AppendLine($"Cliccare sul <a href=\"{urlRedir}\">seguente link</a> per accedere alla pagina di gestione");

                    string msgBody = sbMain.ToString();
                    await sendEmail(emailDest, "Nuovo record Malattia Dipendente", msgBody.Replace($"{Environment.NewLine}", "<br/>"));
                }
                // invalido la cache...
                await ExecFlushRedisPattern($"{rKeyDipendenti}:*");
            }
            catch
            { }
            return answ;
        }

        /// <summary>
        /// Registra approvazione x la richiesta indicata
        /// </summary>
        /// <param name="currItem"></param>
        /// <returns></returns>
        public async Task<bool> RegRichiesteApprova(RegRichiesteModel currItem)
        {
            bool answ = false;
            try
            {
                // modifico approvata sul record
                currItem.Conf = true;
                // scrivo su DB
                answ = dbController.RegRichiesteApprova(currItem);
                if (answ)
                {
                    // recupero info dipendente
                    var listDip = await DipendentiGetAll();
                    var currDip = listDip.FirstOrDefault(x => x.IdxDipendente == currItem.IdxDipendente);
                    // gestisco email notifica...
                    string emailDest = _configuration.GetValue<string>("MailDest:InfoRich") ?? "info@egalware.com";
                    if (!emailDest.Contains(currDip.Email))
                    {
                        emailDest += $",{currDip.Email}";
                    }
                    if (currDip.idxResp > 0)
                    {
                        string mailResp = await emailResp(currDip.idxResp);
                        if (!string.IsNullOrEmpty(mailResp) && !emailDest.Contains(mailResp))
                        {
                            emailDest += $",{mailResp}";
                        }
                    }
                    string urlRedir = _configuration.GetValue<string>("AdmApp:LinkRich") ?? "";
                    DateTime adesso = DateTime.Now;
                    StringBuilder sbMain = new StringBuilder();
                    sbMain.AppendLine($"Il giorno {adesso:yyyy.MM.dd} alle ore {adesso:HH:mm:ss} è stata <b>modificata</b> la richiesta in oggetto.");
                    sbMain.AppendLine("");
                    sbMain.Append("<div style=\"font-size: 1.3em; color: #CC0066;\">");
                    sbMain.Append($"<b>{currDip.Cognome}</b> {currDip.Nome} ({currDip.Matricola})");
                    sbMain.Append("</div>");
                    sbMain.AppendLine("<hr/>");
                    sbMain.AppendLine($"Richiesta: <b>{currItem.CodGiust}</b>");
                    string stato = currItem.Conf ? "CONFERMATA" : "RIFIUTATA";
                    sbMain.AppendLine($"Stato: <b>{stato}</b>");
                    sbMain.AppendLine($"Inizio: <b>{currItem.DtStart}</b>");
                    sbMain.AppendLine($"Fine: <b>{currItem.DtEnd}</b>");
                    sbMain.AppendLine($"Note: <b>{currItem.Note}</b>");
                    sbMain.AppendLine("<hr/>");

                    string msgBody = sbMain.ToString().Replace($"{Environment.NewLine}", "<br/>");
                    await sendEmail(emailDest, $"Aggiornamento Richiesta n.{currItem.IdxRegRich}  ({currItem.CodGiust})", msgBody);
                }
                // invalido la cache...
                await ExecFlushRedisPattern($"{rKeyDipendenti}:*");
                await ExecFlushRedisPattern($"{rKeyDailyData}:*");
                await ExecFlushRedisPattern($"{rKeyLastRegAtt}:*");
                await ExecFlushRedisPattern($"{rKeyParetoRegAtt}:*");
                await ExecFlushRedisPattern($"{rKeyWeekStats}:*");
            }
            catch
            { }
            return answ;
        }

        /// <summary>
        /// Effettua eliminazione record registro richieste dipendente (SE non confermato)
        /// </summary>
        /// <param name="currItem"></param>
        /// <returns></returns>
        public async Task<bool> RegRichiesteDelete(RegRichiesteModel currItem)
        {
            bool answ = false;
            try
            {
                answ = dbController.RegRichiesteDelete(currItem);
                if (answ)
                {
                    // recupero info dipendente
                    var listDip = await DipendentiGetAll();
                    var currDip = listDip.FirstOrDefault(x => x.IdxDipendente == currItem.IdxDipendente);
                    // gestisco email notifica...
                    string emailDest = _configuration.GetValue<string>("MailDest:InfoRich") ?? "info@egalware.com";
                    if (currDip.idxResp > 0)
                    {
                        string mailResp = await emailResp(currDip.idxResp);
                        if (!string.IsNullOrEmpty(mailResp) && !emailDest.Contains(mailResp))
                        {
                            emailDest += $",{mailResp}";
                        }
                    }
                    string urlRedir = _configuration.GetValue<string>("AdmApp:LinkRich") ?? "";
                    StringBuilder sbMain = new StringBuilder();
                    DateTime adesso = DateTime.Now;
                    sbMain.AppendLine($"Il giorno {adesso:yyyy.MM.dd} alle ore {adesso:HH:mm:ss} è stato <b>rimosso</b> un record di registrazione richiesta utente");
                    sbMain.AppendLine("");
                    sbMain.Append("<div style=\"font-size: 1.3em; color: #CC0066;\">");
                    sbMain.Append($"<b>{currItem.DipNav.Cognome}</b> {currItem.DipNav.Nome} ({currItem.DipNav.Matricola})");
                    //sbMain.Append($"<b>{currDip.Cognome}</b> {currDip.Nome} ({currDip.Matricola})");
                    sbMain.Append("</div>");
                    sbMain.AppendLine("<hr/>");
                    sbMain.AppendLine($"Richiesta: <b>{currItem.CodGiust}</b>");
                    sbMain.AppendLine($"Periodo: <b>{currItem.DtStart}</b> --> <b>{currItem.DtEnd}</b>");
                    sbMain.AppendLine($"Note: <b>{currItem.Note}</b>");
                    sbMain.AppendLine("<hr/>");
                    sbMain.AppendLine($"Cliccare sul <a href=\"{urlRedir}\">seguente link</a> per accedere alla pagina di gestione");
                    string msgBody = sbMain.ToString();
                    await sendEmail(emailDest, $"Eliminazione Richiesta Dipendente | {currItem.CodGiust}", msgBody.Replace($"{Environment.NewLine}", "<br/>"));
                }
                // invalido la cache...
                await ExecFlushRedisPattern($"{rKeyDipendenti}:*");
                await ExecFlushRedisPattern($"{rKeyDailyData}:*");
                await ExecFlushRedisPattern($"{rKeyLastRegAtt}:*");
                await ExecFlushRedisPattern($"{rKeyParetoRegAtt}:*");
                await ExecFlushRedisPattern($"{rKeyWeekStats}:*");
            }
            catch
            { }
            return answ;
        }

        /// <summary>
        /// Restituisce elenco richieste dipendente
        /// </summary>
        /// <param name="idxDipendente">Dipendente interessato</param>
        /// <param name="dtFrom">Inizio periodo richiesto</param>
        /// <param name="dtTo">Fine periodo richiesto</param>
        /// <returns></returns>
        public async Task<List<RegRichiesteModel>> RegRichiesteGetByDip(int idxDipendente, DateTime dtFrom, DateTime dtTo)
        {
            string source = "DB";
            List<RegRichiesteModel>? dbResult = new List<RegRichiesteModel>();
            string currKey = $"{rKeyDipendenti}:{idxDipendente}:RegRichieste:{dtFrom:yyyyMMdd}:{dtTo:yyyyMMdd}";
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            string? rawData = await redisDb.StringGetAsync(currKey);
            if (!string.IsNullOrEmpty(rawData))
            {
                source = "REDIS";
                var tempResult = JsonConvert.DeserializeObject<List<RegRichiesteModel>>(rawData);
                if (tempResult == null)
                {
                    dbResult = new List<RegRichiesteModel>();
                }
                else
                {
                    dbResult = tempResult;
                }
            }
            else
            {
                dbResult = dbController.RegRichiesteGetByDip(idxDipendente, dtFrom, dtTo);
                rawData = JsonConvert.SerializeObject(dbResult, JSSettings);
                await redisDb.StringSetAsync(currKey, rawData, FastCache);
            }
            if (dbResult == null)
            {
                dbResult = new List<RegRichiesteModel>();
            }
            stopWatch.Stop();
            TimeSpan ts = stopWatch.Elapsed;
            Log.Debug($"RegRichiesteGetByDip | {source} in: {ts.TotalMilliseconds} ms");
            return dbResult;
        }

        /// <summary>
        /// Registra o aggiorna record registro richieste
        /// </summary>
        /// <param name="currItem"></param>
        /// <returns></returns>
        public async Task<bool> RegRichiesteUpsert(RegRichiesteModel currItem)
        {
            bool answ = false;
            try
            {
                bool isNew = currItem.IdxRegRich == 0;
                // scrivo su DB
                answ = dbController.RegRichiesteUpsert(currItem);
                if (answ)
                {
                    // recupero info dipendente
                    var listDip = await DipendentiGetAll();
                    var currDip = listDip.FirstOrDefault(x => x.IdxDipendente == currItem.IdxDipendente);
                    // gestisco email notifica...
                    string emailDest = _configuration.GetValue<string>("MailDest:InfoRich") ?? "info@egalware.com";
                    if (!emailDest.Contains(currDip.Email))
                    {
                        emailDest += $",{currDip.Email}";
                    }
                    if (currDip.idxResp > 0)
                    {
                        string mailResp = await emailResp(currDip.idxResp);
                        if (!string.IsNullOrEmpty(mailResp) && !emailDest.Contains(mailResp))
                        {
                            emailDest += $",{mailResp}";
                        }
                    }
                    string urlRedir = _configuration.GetValue<string>("AdmApp:LinkRich") ?? "";
                    StringBuilder sbMain = new StringBuilder();
                    DateTime adesso = DateTime.Now;
                    sbMain.AppendLine($"Il giorno {adesso:yyyy.MM.dd} alle ore {adesso:HH:mm:ss} è stato inserito una nuova richiesta dipendente");
                    sbMain.AppendLine("");
                    sbMain.Append("<div style=\"font-size: 1.3em;\">");
                    sbMain.Append($"<b>{currDip.Cognome}</b> {currDip.Nome} ({currDip.Matricola})");
                    sbMain.Append("</div>");
                    sbMain.AppendLine("<hr/>");
                    sbMain.AppendLine($"Richiesta: <b>{currItem.CodGiust}</b>");
                    if(!isNew)
                    {
                        string stato = currItem.Conf ? "CONFERMATA" : "RIFIUTATA";
                        sbMain.AppendLine($"Stato: <b>{stato}</b>");
                    }
                    sbMain.AppendLine($"Periodo: <b>{currItem.DtStart}</b> --> <b>{currItem.DtEnd}</b>");
                    sbMain.AppendLine($"Note: <b>{currItem.Note}</b>");
                    sbMain.AppendLine("<hr/>");
                    sbMain.AppendLine($"Cliccare sul <a href=\"{urlRedir}\">seguente link</a> per accedere alla pagina di gestione");

                    string msgBody = sbMain.ToString();
                    string subj = isNew ? $"Nuovo record Richiesta {currItem.CodGiust} Dipendente" : $"Aggiornamento Richiesta n.{currItem.IdxRegRich}  ({currItem.CodGiust})";
                    await sendEmail(emailDest, subj, msgBody.Replace($"{Environment.NewLine}", "<br/>"));
                }
                // invalido la cache...
                await ExecFlushRedisPattern($"{rKeyDipendenti}:*");
                await ExecFlushRedisPattern($"{rKeyDailyData}:*");
                await ExecFlushRedisPattern($"{rKeyLastRegAtt}:*");
                await ExecFlushRedisPattern($"{rKeyParetoRegAtt}:*");
                await ExecFlushRedisPattern($"{rKeyWeekStats}:*");
            }
            catch
            { }
            return answ;
        }

        /// <summary>
        /// Recupera l'elenco dei dettagli attività e timbrature di un dipendente, dato periodo riferimento
        /// </summary>
        /// <param name="idxDipendente">Dipendente interessato</param>
        /// <param name="periodo">Periodo di riferimento</param>
        /// <returns></returns>
        public async Task<ReportDataDTO> ReportDetails(int idxDipendente, DtUtils.Periodo periodo)
        {
            string source = "DB";
            ReportDataDTO? dbResult = new ReportDataDTO();
            string currKey = $"{rKeyReportData}:{idxDipendente}:{periodo.Inizio.ToString("yyyy-MM-dd")}:{periodo.Fine.ToString("yyyy-MM-dd")}";
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            string? rawData = await redisDb.StringGetAsync(currKey);
            if (!string.IsNullOrEmpty(rawData))
            {
                source = "REDIS";
                var tempResult = JsonConvert.DeserializeObject<ReportDataDTO>(rawData);
                if (tempResult == null)
                {
                    dbResult = new ReportDataDTO();
                }
                else
                {
                    dbResult = tempResult;
                }
            }
            else
            {
                dbResult = dbController.ReportDetails(idxDipendente, periodo);
                rawData = JsonConvert.SerializeObject(dbResult, JSSettings);
                await redisDb.StringSetAsync(currKey, rawData, LongCache);
            }
            if (dbResult == null)
            {
                dbResult = new ReportDataDTO();
            }
            stopWatch.Stop();
            TimeSpan ts = stopWatch.Elapsed;
            Log.Debug($"ReportDetails | {source} in: {ts.TotalMilliseconds} ms");
            return dbResult;
        }

        /// <summary>
        /// Reset dati report x dipendente, se 0 = tutti
        /// </summary>
        /// <param name="idxDipendente"></param>
        /// <returns></returns>
        public async Task ReportResetCacheDip(int idxDipendente)
        {
            if (idxDipendente == 0)
            {
                await ExecFlushRedisPattern($"{rKeyReportData}:*");
            }
            else
            {
                await ExecFlushRedisPattern($"{rKeyReportData}:{idxDipendente}:*");
            }
        }

        /// <summary>
        /// Recupera l'elenco dei Rilievi temperatura nel periodo indicato x dipendente
        /// </summary>
        /// <param name="idxDipendente">Dipendente interessato</param>
        /// <param name="dtInizio">Data di riferimento (ultima/corrente)</param>
        /// <param name="dtFine">NUm settimane precedenti da recuperare</param>
        /// <returns></returns>
        public async Task<List<RilievoTempModel>> RilTempList(int idxDipendente, DateTime dtInizio, DateTime dtFine)
        {
            string source = "DB";
            List<RilievoTempModel>? dbResult = new List<RilievoTempModel>();
            string currKey = $"{rKeyRilTemp}:{dtInizio:yyyyMMdd}:{dtFine:yyyMMdd}";
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            string? rawData = await redisDb.StringGetAsync(currKey);
            if (!string.IsNullOrEmpty(rawData))
            {
                source = "REDIS";
                var tempResult = JsonConvert.DeserializeObject<List<RilievoTempModel>>(rawData);
                if (tempResult == null)
                {
                    dbResult = new List<RilievoTempModel>();
                }
                else
                {
                    dbResult = tempResult;
                }
            }
            else
            {
                dbResult = dbController.RilTempList(idxDipendente, dtInizio, dtFine);
                rawData = JsonConvert.SerializeObject(dbResult, JSSettings);
                await redisDb.StringSetAsync(currKey, rawData, FastCache);
            }
            if (dbResult == null)
            {
                dbResult = new List<RilievoTempModel>();
            }
            stopWatch.Stop();
            TimeSpan ts = stopWatch.Elapsed;
            Log.Debug($"RilTempList | {source} in: {ts.TotalMilliseconds} ms");
            return dbResult;
        }

        public async Task<bool> RilTempUpdate(RilievoTempModel currItem)
        {
            bool answ = false;
            try
            {
                dbController.RilTempUpdate(currItem);
                // invalido la cache...
                await ExecFlushRedisPattern($"{rKeyRilTemp}:*");
                await ExecFlushRedisPattern($"{rKeyDailyData}:*");
                await ExecFlushRedisPattern($"{rKeyLastRegAtt}:*");
                await ExecFlushRedisPattern($"{rKeyParetoRegAtt}:*");
                await ExecFlushRedisPattern($"{rKeyWeekStats}:*");
                answ = true;
            }
            catch
            { }
            return answ;
        }

        public void rollBackEdit(object item)
        {
            dbController.rollBackEntity(item);
        }

        /// <summary>
        /// Elenco timbrature di un giorno
        /// </summary>
        /// <param name="dateRif"></param>
        /// <param name="IdxDip"></param>
        /// <returns></returns>
        public async Task<List<TimbratureModel>> TimbratureDay(DateTime dateRif, int IdxDip)
        {
            await Task.Delay(1);
            List<TimbratureModel>? dbResult = new List<TimbratureModel>();
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            dbResult = dbController.TimbratureDay(dateRif, IdxDip);
            stopWatch.Stop();
            TimeSpan ts = stopWatch.Elapsed;
            Log.Trace($"Effettuata lettura da DB + caching per TimbratureDay: {ts.TotalMilliseconds} ms");
            return dbResult;
        }

        public async Task<bool> TimbratureDelete(TimbratureModel currItem)
        {
            bool answ = false;
            try
            {
                dbController.TimbratureDelete(currItem);
                // invalido la cache...
                await FlushRedisCache();
                answ = true;
            }
            catch
            { }
            return answ;
        }

        public async Task<bool> TimbratureUpdate(TimbratureModel currItem)
        {
            bool answ = false;
            try
            {
                dbController.TimbratureUpdate(currItem);
                // invalido la cache...
                await FlushRedisCache();
                answ = true;
            }
            catch
            { }
            return answ;
        }

        /// <summary>
        /// Recupera l'elenco delle ultime attività inserite da un dipendente
        /// </summary>
        /// <param name="idxDipendente">Dipendente interessato</param>
        /// <param name="numRec">Num record da recuperare</param>
        /// <returns></returns>
        public async Task<List<RegAttivitaModel>> UserLastRec(int idxDipendente, int numRec)
        {
            string source = "DB";
            DateTime oggi = DateTime.Today;
            List<RegAttivitaModel>? dbResult = new List<RegAttivitaModel>();
            string currKey = $"{rKeyLastRegAtt}:{idxDipendente}:{oggi.ToString("yyyy-MM-dd")}:{numRec}";
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            string? rawData = await redisDb.StringGetAsync(currKey);
            if (!string.IsNullOrEmpty(rawData))
            {
                source = "REDIS";
                var tempResult = JsonConvert.DeserializeObject<List<RegAttivitaModel>>(rawData);
                if (tempResult == null)
                {
                    dbResult = new List<RegAttivitaModel>();
                }
                else
                {
                    dbResult = tempResult;
                }
            }
            else
            {
                dbResult = dbController.UserLastRec(idxDipendente, numRec);
                rawData = JsonConvert.SerializeObject(dbResult, JSSettings);
                await redisDb.StringSetAsync(currKey, rawData, FastCache);
            }
            if (dbResult == null)
            {
                dbResult = new List<RegAttivitaModel>();
            }
            stopWatch.Stop();
            TimeSpan ts = stopWatch.Elapsed;
            Log.Debug($"UserLastRec | {source} in: {ts.TotalMilliseconds} ms");
            return dbResult;
        }

        #endregion Public Methods

        #region Protected Fields

        protected const string passPhrase = "6E1DA6B4-4647-4578-AB4F-01360E2B7E68";
        protected const string redisBaseAddr = "GPW:WrkLog";
        protected const string rKeyAKV = $"{redisBaseAddr}:Cache:AKV";
        protected const string rKeyAnOrDip = $"{redisBaseAddr}:Cache:AnOrariDip";
        protected const string rKeyCalcOreFase = $"{redisBaseAddr}:Cache:CalcOreFase";
        protected const string rKeyCalcOreProj = $"{redisBaseAddr}:Cache:CalcOreProj";
        protected const string rKeyCalendari = $"{redisBaseAddr}:Cache:Calendari";
        protected const string rKeyCliAll = $"{redisBaseAddr}:Cache:CliAll";
        protected const string rKeyConfig = $"{redisBaseAddr}:Cache:Config";
        protected const string rKeyDailyData = $"{redisBaseAddr}:Cache:DailyData";
        protected const string rKeyDipendenti = $"{redisBaseAddr}:Cache:Dipendenti";
        protected const string rKeyEventListDip = $"{redisBaseAddr}:Cache:EventListDip";
        protected const string rKeyFasi = $"{redisBaseAddr}:Cache:Fasi";
        protected const string rKeyFasiAll = $"{redisBaseAddr}:Cache:Fasi:All";
        protected const string rKeyFasiAnc = $"{redisBaseAddr}:Cache:Fasi:Ancest";
        protected const string rKeyFasiByProj = $"{redisBaseAddr}:Cache:Fasi:ByProj";
        protected const string rKeyFasiSearch = $"{redisBaseAddr}:Cache:Fasi:Search";
        protected const string rKeyGiust = $"{redisBaseAddr}:Cache:Giustif";
        protected const string rKeyGrpAll = $"{redisBaseAddr}:Cache:GrpAll";
        protected const string rKeyGrpUser = $"{redisBaseAddr}:Cache:GrpUser";
        protected const string rKeyLastRegAtt = $"{redisBaseAddr}:Cache:LastRegAtt";
        protected const string rKeyParetoRegAtt = $"{redisBaseAddr}:Cache:ParetoRegAtt";
        protected const string rKeyProjAll = $"{redisBaseAddr}:Cache:ProjAll";
        protected const string rKeyProjCalc = $"{redisBaseAddr}:Cache:ProjCalc";
        protected const string rKeyReportData = $"{redisBaseAddr}:Cache:ReportData";
        protected const string rKeyRilTemp = $"{redisBaseAddr}:Cache:RilTemp";
        protected const string rKeyStatPresDay = $"{redisBaseAddr}:Cache:StatPresDay";
        protected const string rKeyTags = $"{redisBaseAddr}:Cache:Tags";
        protected const string rKeyVC19 = $"{redisBaseAddr}:Cache:VC19";
        protected const string rKeyVetoIns = $"{redisBaseAddr}:Cache:VetoInsert";
        protected const string rKeyWeekStats = $"{redisBaseAddr}:Cache:WeekStats";
        protected static string connStringBBM = "";
        protected Random rnd = new Random();

        #endregion Protected Fields

        #region Protected Methods

        /// <summary>
        /// Calcola email del responsabile dato idx
        /// </summary>
        /// <param name="idxResp"></param>
        /// <returns></returns>
        protected async Task<string> emailResp(int idxResp)
        {
            string answ = "";
            var listDip = await DipendentiGetAll();
            // recupero email resp...
            if (idxResp > 0)
            {
                var recResp = listDip.FirstOrDefault(x => x.IdxDipendente == idxResp);
                if (recResp != null)
                {
                    answ = $"{recResp.Email}";
                }
            }
            return answ;
        }

        /// <summary>
        /// Invio email tramite libreria
        /// </summary>
        /// <param name="destList"></param>
        /// <param name="subject"></param>
        /// <param name="message"></param>
        /// <returns></returns>
        protected async Task sendEmail(string destList, string subject, string message)
        {
            List<string> emailDestList = destList.Split(",").ToList();
            foreach (var dest in emailDestList)
            {
                try
                {
                    await _emailSender.SendEmailAsync(dest, subject, message);
                }
                catch (Exception exc)
                {
                    Log.Error($"Eccezione durante invio email:{Environment.NewLine}dest: {dest} | subject {subject}{Environment.NewLine}{exc}");
                }
            }
        }

        #endregion Protected Methods

        #region Private Fields

        private static IConfiguration _configuration = null!;
        private static JsonSerializerSettings? JSSettings;
        private static Logger Log = LogManager.GetCurrentClassLogger();
        private readonly IEmailSender _emailSender;

        /// <summary>
        /// Durata cache lunga IN SECONDI (5 min std)
        /// </summary>
        private int cacheTtlLong = 60 * 5;

        /// <summary>
        /// Durata cache breve IN SECONDI (1 min)
        /// </summary>
        private int cacheTtlShort = 60 * 1;

        /// <summary>
        /// Oggetto per connessione a REDIS
        /// </summary>
        private IConnectionMultiplexer redisConn;

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

        #endregion Private Fields

        #region Private Properties

        /// <summary>
        /// Durata cache veloce (+ perturbazione percentuale +/-10%)
        /// </summary>
        private TimeSpan FastCache
        {
            get => TimeSpan.FromSeconds(cacheTtlShort * rnd.Next(900, 1100) / 1000);
        }

        /// <summary>
        /// Durata cache lunga (+ perturbazione percentuale +/-10%)
        /// </summary>
        private TimeSpan LongCache
        {
            get => TimeSpan.FromSeconds(cacheTtlLong * rnd.Next(900, 1100) / 1000);
        }

        /// <summary>
        /// Durata cache ultra-lunga (+ perturbazione percentuale +/-10%)
        /// </summary>
        private TimeSpan UltraLongCache
        {
            get => TimeSpan.FromSeconds(cacheTtlLong * 10 * rnd.Next(900, 1100) / 1000);
        }

        #endregion Private Properties

        #region Private Methods

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

            return answ;
        }

        #endregion Private Methods
    }
}