using DnsClient.Protocol;
using Microsoft.Data.SqlClient;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
using MP.Data.DatabaseModels;
using NLog;
using System;
using System.Collections.Generic;
using System.Drawing.Drawing2D;
using System.Linq;
using static MP.Data.Objects.Enums;

namespace MP.Data.Controllers
{
    public class MpStatsController : IDisposable
    {
        #region Public Constructors

        public MpStatsController(IConfiguration configuration)
        {
            _configuration = configuration;
            Log.Info("Avviata classe MpStatsController");
        }

        #endregion Public Constructors

        #region Public Methods

        /// <summary>
        /// Elenco Azioni (decodifica)
        /// </summary>
        /// <returns></returns>
        public List<AzioniUL> ActionsGetAll()
        {
            List<AzioniUL> dbResult = new List<AzioniUL>();
            using (var dbCtx = new MoonPro_STATSContext(_configuration))
            {
                dbResult = dbCtx
                    .DbSetAzioniUL
                    .ToList();
            }
            return dbResult;
        }

        /// <summary>
        /// Elenco tabella Articoli da filtro
        /// </summary>
        /// <param name="numRecord"></param>
        /// <param name="searchVal"></param>
        /// <returns></returns>
        public List<StatsAnagArticoli> ArticoliGetSearch(int numRecord, string searchVal = "")
        {
            List<StatsAnagArticoli> dbResult = new List<StatsAnagArticoli>();
            using (var dbCtx = new MoonPro_STATSContext(_configuration))
            {
                dbResult = dbCtx
                .DbSetArticoli
                .Where(x => x.CodArticolo.Contains(searchVal) || x.DescArticolo.Contains(searchVal) || x.Disegno.Contains(searchVal) || string.IsNullOrEmpty(searchVal))
                .OrderBy(x => x.CodArticolo)
                .Take(numRecord)
                .ToList();
            }
            return dbResult;
        }

        public DateTime CalcNextExe(TaskListModel taskRec)
        {
            DateTime dtNext = DateTime.Today;
            try
            {
                // calcolo next exec da tipo...
                switch (taskRec.Freq)
                {
                    case TaskFreqType.ND:
                        dtNext = taskRec.DtLastExec.AddDays(taskRec.Cad);
                        break;

                    case TaskFreqType.Sec:
                        dtNext = taskRec.DtLastExec.AddSeconds(taskRec.Cad);
                        break;

                    case TaskFreqType.Min:
                        dtNext = taskRec.DtLastExec.AddMinutes(taskRec.Cad);
                        break;

                    case TaskFreqType.Hour:
                        dtNext = taskRec.DtLastExec.AddHours(taskRec.Cad);
                        break;

                    case TaskFreqType.Day:
                        dtNext = taskRec.DtLastExec.AddDays(taskRec.Cad);
                        break;

                    case TaskFreqType.Week:
                        dtNext = taskRec.DtLastExec.AddDays(7 * taskRec.Cad);
                        break;

                    case TaskFreqType.Month:
                        dtNext = taskRec.DtLastExec.AddMonths(taskRec.Cad);
                        break;

                    case TaskFreqType.Year:
                        dtNext = taskRec.DtLastExec.AddYears(taskRec.Cad);
                        break;

                    default:
                        dtNext = taskRec.DtLastExec.AddDays(taskRec.Cad);
                        break;
                }
            }
            catch (Exception exc)
            {
                Log.Error($"Eccezione in CalcNextExe{Environment.NewLine}{exc}");
            }
            return dtNext;
        }

        /// <summary>
        /// Elenco tabella Articoli da filtro
        /// </summary>
        /// <param name="numRecord"></param>
        /// <param name="searchVal"></param>
        /// <returns></returns>
        public List<StatsODL> CommesseGetSearch(int numRecord, string searchVal = "")
        {
            List<StatsODL> dbResult = new List<StatsODL>();
            using (var dbCtx = new MoonPro_STATSContext(_configuration))
            {
                dbResult = dbCtx
                .DbSetODL
                .Where(x => x.KeyRichiesta.Contains(searchVal) || string.IsNullOrEmpty(searchVal))
                .OrderBy(x => x.KeyRichiesta)
                .Take(numRecord)
                .ToList();
            }
            return dbResult;
        }

        public void Dispose()
        {
        }

        /// <summary>
        /// Chiamata esecuzione di un singolo task programmato
        /// </summary>
        /// <param name="TaskId"></param>
        /// <param name="SchedNext">Se true rischedula successiva chiamata</param>
        /// <returns></returns>
        public TaskResultModel ExecuteTask(int TaskId, bool SchedNext)
        {
            TaskResultModel callRes = new TaskResultModel();
            using (var dbCtx = new MoonPro_STATSContext(_configuration))
            {
                // imposto timeout a 5 min
                //var currTimeout = dbCtx.Database.GetCommandTimeout();
                dbCtx.Database.SetCommandTimeout(TimeSpan.FromMinutes(5));
                try
                {
                    DateTime dtStart = DateTime.Now;
                    // recupero i dati da richiamare...
                    var currRec = dbCtx
                                .DbSetTaskList
                                .Where(x => x.TaskId == TaskId)
                                .FirstOrDefault();
                    if (currRec != null)
                    {
                        // recupero comando
                        string sqlCommand = currRec.Command;
                        string rawParams = currRec.Args;
                        callRes = dbCtx
                                    .DbSetTaskResult
                                    .FromSqlRaw($"EXEC {sqlCommand} {rawParams}")
                                    .AsNoTracking()
                                    .AsEnumerable()
                                    .FirstOrDefault();
                        DateTime dtEnd = DateTime.Now;

                        // preparo record esecuzione...
                        TaskExecModel resRec = new TaskExecModel()
                        {
                            TaskId = TaskId,
                            DtStart = dtStart,
                            DtEnd = dtEnd,
                            IsError = callRes.ExecResult < 0,
                            Result = callRes.TextResult
                        };
                        dbCtx
                            .DbSetTaskExe
                            .Add(resRec);

                        // aggiorno record chiamata...
                        currRec.DtLastExec = dtStart;
                        currRec.LastResult = resRec.Result;
                        currRec.LastIsError = resRec.IsError;
                        currRec.LastDuration = dtEnd.Subtract(dtStart).TotalSeconds;
                        // solo se richiesto rischedulazione ricalcola chiamata
                        if (SchedNext)
                        {
                            // calcolo prossima esecuzione...
                            currRec.DtNextExec = CalcNextExe(currRec);
                        }
                        // segno modificato
                        dbCtx.Entry(currRec).State = EntityState.Modified;

                        // salvo modifiche!
                        dbCtx.SaveChanges();
                    }
                }
                catch (Exception exc)
                {
                    Log.Error($"Eccezione in ExecuteSqlCommand{Environment.NewLine}{exc}");
                }
            }
            return callRes;
        }

        /// <summary>
        /// Elenco da tabella Macchine
        /// </summary>
        /// <returns></returns>
        public List<Macchine> MacchineGetAll()
        {
            List<Macchine> dbResult = new List<Macchine>();
            using (var dbCtx = new MoonPro_STATSContext(_configuration))
            {
                dbResult = dbCtx
                            .DbSetMacchine
                            .OrderBy(x => x.IdxMacchina)
                            .ToList();
            }
            return dbResult;
        }

        /// <summary>
        /// Annulla modifiche su una specifica entity (cancel update)
        /// </summary>
        /// <param name="item"></param>
        /// <returns></returns>
        public bool RollBackEntity(object item)
        {
            bool answ = false;
            using (var dbCtx = new MoonPro_STATSContext(_configuration))
            {
                try
                {
                    if (dbCtx.Entry(item).State == Microsoft.EntityFrameworkCore.EntityState.Deleted || dbCtx.Entry(item).State == Microsoft.EntityFrameworkCore.EntityState.Modified)
                    {
                        dbCtx.Entry(item).Reload();
                    }
                }
                catch (Exception exc)
                {
                    Log.Error($"Eccezione in rollBackEntity{Environment.NewLine}{exc}");
                }
            }
            return answ;
        }

        /// <summary>
        /// Elenco tabella controlli da filtro
        /// </summary>
        /// <param name="numRecord"></param>
        /// <param name="searchVal"></param>
        /// <returns></returns>
        public List<ResControlli> StatControlliGetAll(DateTime DataStart, DateTime DataEnd, string IdxMacchina, int IdxODL, string KeyRichiesta, string CodArticolo)
        {
            List<ResControlli> dbResult = new List<ResControlli>();
            using (var dbCtx = new MoonPro_STATSContext(_configuration))
            {
                var dataFrom = new SqlParameter("@dataFrom", DataStart);
                var dataTo = new SqlParameter("@dataTo", DataEnd);
                var idxMacchina = new SqlParameter("@IdxMacchina", IdxMacchina);
                var idxODL = new SqlParameter("@IdxODL", IdxODL);
                var keyRichiesta = new SqlParameter("@KeyRichiesta", KeyRichiesta);
                var codArticolo = new SqlParameter("@CodArticolo", CodArticolo);

                dbResult = dbCtx
                    .DbSetControlli
                    .FromSqlRaw("EXEC stp_UI_RC_GetByFilter @dataFrom,@dataTo,@IdxMacchina,@IdxODL,@KeyRichiesta,@CodArticolo", dataFrom, dataTo, idxMacchina, idxODL, keyRichiesta, codArticolo)
                    .ToList();
            }
            return dbResult;
        }

        /// <summary>
        /// Elenco tabella DDB da filtro
        /// </summary>
        /// <param name="DataStart"></param>
        /// <param name="DataEnd"></param>
        /// <param name="IdxMacchina"></param>
        /// <param name="IdxODL"></param>
        /// <param name="KeyRichiesta"></param>
        /// <param name="CodArticolo"></param>
        /// <param name="FirstRecord"></param>
        /// <param name="NumRecord"></param>
        /// <returns></returns>
        public List<DdbTurni> StatDdbGetAll(DateTime DataStart, DateTime DataEnd, string IdxMacchina, int IdxODL, string KeyRichiesta, string CodArticolo, int FirstRecord, int NumRecord)
        {
            List<DdbTurni> dbResult = new List<DdbTurni>();
            using (var dbCtx = new MoonPro_STATSContext(_configuration))
            {
                var dataFrom = new SqlParameter("@dataFrom", DataStart);
                var dataTo = new SqlParameter("@dataTo", DataEnd);
                var idxMacchina = new SqlParameter("@IdxMacchina", IdxMacchina);
                var idxODL = new SqlParameter("@IdxODL", IdxODL);
                var keyRichiesta = new SqlParameter("@KeyRichiesta", KeyRichiesta);
                var codArticolo = new SqlParameter("@CodArticolo", CodArticolo);
                var firstRecord = new SqlParameter("@FirstRecord", FirstRecord);
                var numRecord = new SqlParameter("@NumRecord", NumRecord);

                dbResult = dbCtx
                    .DbSetDdbTurni
                    .FromSqlRaw("EXEC stp_UI_DDBTurni_GetByFilter @dataFrom,@dataTo,@IdxMacchina,@IdxODL,@KeyRichiesta,@CodArticolo,@FirstRecord,@NumRecord", dataFrom, dataTo, idxMacchina, idxODL, keyRichiesta, codArticolo, firstRecord, numRecord)
                    .ToList();
            }
            return dbResult;
        }

        /// <summary>
        /// Elenco tabella DDB da filtro
        /// </summary>
        /// <param name="DataStart"></param>
        /// <param name="DataEnd"></param>
        /// <param name="IdxMacchina"></param>
        /// <param name="IdxODL"></param>
        /// <param name="KeyRichiesta"></param>
        /// <param name="CodArticolo"></param>
        /// <returns></returns>
        public int StatDdbGetCount(DateTime DataStart, DateTime DataEnd, string IdxMacchina, int IdxODL, string KeyRichiesta, string CodArticolo)
        {
            int numResult = 0;
            using (var dbCtx = new MoonPro_STATSContext(_configuration))
            {
                numResult = dbCtx
                  .DbSetDdbTurni
                  .Where(x => (x.IdxMacchina == IdxMacchina || IdxMacchina == "*") && (x.IdxOdl == IdxODL || IdxODL == -999) && (x.KeyRichiesta == KeyRichiesta || KeyRichiesta == "*") && (x.CodArticolo == CodArticolo || CodArticolo == "*") && (x.InizioPeriodo >= DataStart && x.InizioPeriodo <= DataEnd))
                  .Count();
            }
            return numResult;
        }

        /// <summary>
        /// Restituisce dataset ODL Energy filtrato
        /// </summary>
        /// <param name="IdxMacchina">Macchina singola, se "" = tutte</param>
        /// <param name="DtStart">Data inizio selezione odl (inizio/fine)</param>
        /// <param name="DtEnd">Data fine selezione odl (inizio/fine)</param>
        /// <param name="IdxODL">IdxOdl, se 0 = tutti</param>
        /// <param name="KeyRichiesta">Key Richiesta, se "*" = tutti</param>
        /// <param name="CodArticolo">Cod Articolo, se "*" = tutti</param>
        /// <returns></returns>
        public List<OdlEnergyModel> StatOdlEnergyGetFilt(string IdxMacchina, DateTime DtStart, DateTime DtEnd, int IdxODL, string KeyRichiesta, string CodArticolo)
        {
            List<OdlEnergyModel> dbResult = new List<OdlEnergyModel>();
            using (var dbCtx = new MoonPro_STATSContext(_configuration))
            {
                var dataFrom = new SqlParameter("@dataFrom", DtStart);
                var dataTo = new SqlParameter("@dataTo", DtEnd);
                var idxMacchina = new SqlParameter("@idxMacchina", IdxMacchina);
                var idxODL = new SqlParameter("@IdxODL", IdxODL);
                var keyRichiesta = new SqlParameter("@KeyRichiesta", KeyRichiesta);
                var codArticolo = new SqlParameter("@CodArticolo", CodArticolo);

                dbResult = dbCtx
                    .DbSetOdlEnergy
                    .FromSqlRaw("EXEC stp_UI_ODL_Energy_GetByFilter @dataFrom,@dataTo,@IdxMacchina,@IdxODL,@KeyRichiesta,@CodArticolo", dataFrom, dataTo, idxMacchina, idxODL, keyRichiesta, codArticolo)
                    .ToList();
            }
            return dbResult;
        }

        /// <summary>
        /// Elenco tabella ODL da filtro
        /// </summary>
        /// <param name="numRecord"></param>
        /// <param name="searchVal"></param>
        /// <returns></returns>
        public List<StatsODL> StatOdlGetAll(DateTime DataStart, DateTime DataEnd, string IdxMacchina, int IdxODL, string KeyRichiesta, string CodArticolo)
        {
            List<StatsODL> dbResult = new List<StatsODL>();
            using (var dbCtx = new MoonPro_STATSContext(_configuration))
            {
                var dataFrom = new SqlParameter("@dataFrom", DataStart);
                var dataTo = new SqlParameter("@dataTo", DataEnd);
                var idxMacchina = new SqlParameter("@IdxMacchina", IdxMacchina);
                var idxODL = new SqlParameter("@IdxODL", IdxODL);
                var keyRichiesta = new SqlParameter("@KeyRichiesta", KeyRichiesta);
                var codArticolo = new SqlParameter("@CodArticolo", CodArticolo);

                dbResult = dbCtx
                    .DbSetODL
                    .FromSqlRaw("EXEC stp_UI_Odl_GetByFilter @dataFrom,@dataTo,@IdxMacchina,@IdxODL,@KeyRichiesta,@CodArticolo", dataFrom, dataTo, idxMacchina, idxODL, keyRichiesta, codArticolo)
                    .ToList();
            }
            return dbResult;
        }

        /// <summary>
        /// Elenco tabella scarti da filtro
        /// </summary>
        /// <param name="DataStart"></param>
        /// <param name="DataEnd"></param>
        /// <param name="IdxMacchina"></param>
        /// <param name="DataEnd"></param>
        /// <returns></returns>
        public List<ResScarti> StatScartiGetAll(DateTime DataStart, DateTime DataEnd, string IdxMacchina, int IdxODL, string KeyRichiesta, string CodArticolo)
        {
            List<ResScarti> dbResult = new List<ResScarti>();
            using (var dbCtx = new MoonPro_STATSContext(_configuration))
            {
                var dataFrom = new SqlParameter("@dataFrom", DataStart);
                var dataTo = new SqlParameter("@dataTo", DataEnd);
                var idxMacchina = new SqlParameter("@IdxMacchina", IdxMacchina);
                var idxODL = new SqlParameter("@IdxODL", IdxODL);
                var keyRichiesta = new SqlParameter("@KeyRichiesta", KeyRichiesta);
                var codArticolo = new SqlParameter("@CodArticolo", CodArticolo);

                dbResult = dbCtx
                    .DbSetScarti
                    .FromSqlRaw("EXEC stp_UI_RS_GetByFilter @dataFrom,@dataTo,@IdxMacchina,@IdxODL,@KeyRichiesta,@CodArticolo", dataFrom, dataTo, idxMacchina, idxODL, keyRichiesta, codArticolo)
                    .ToList();
            }
            return dbResult;
        }

        /// <summary>
        /// Elenco tabella TurniOee da filtro
        /// </summary>
        /// <param name="DataStart"></param>
        /// <param name="DataEnd"></param>
        /// <param name="IdxMacchina"></param>
        /// <param name="DataEnd"></param>
        /// <returns></returns>
        public List<TurniOee> StatTurniOeeGetAll(DateTime DataStart, DateTime DataEnd, string IdxMacchina, int IdxODL, string KeyRichiesta, string CodArticolo)
        {
            List<TurniOee> dbResult = new List<TurniOee>();
            using (var dbCtx = new MoonPro_STATSContext(_configuration))
            {
                var dataFrom = new SqlParameter("@dataFrom", DataStart);
                var dataTo = new SqlParameter("@dataTo", DataEnd);
                var idxMacchina = new SqlParameter("@IdxMacchina", IdxMacchina);
                var idxODL = new SqlParameter("@IdxODL", IdxODL);
                var keyRichiesta = new SqlParameter("@KeyRichiesta", KeyRichiesta);
                var codArticolo = new SqlParameter("@CodArticolo", CodArticolo);

                dbResult = dbCtx
                    .DbSetTurniOee
                    .FromSqlRaw("EXEC stp_UI_TurniOee_GetByFilter @dataFrom,@dataTo,@IdxMacchina,@IdxODL,@KeyRichiesta,@CodArticolo", dataFrom, dataTo, idxMacchina, idxODL, keyRichiesta, codArticolo)
                    .ToList();
            }
            return dbResult;
        }

        /// <summary>
        /// Elenco tabella UserLog da filtro
        /// </summary>
        /// <param name="numRecord"></param>
        /// <param name="searchVal"></param>
        /// <returns></returns>
        public List<UserActionLog> StatUserLogGetAll(DateTime DataStart, DateTime DataEnd, string IdxMacchina, int IdxODL, string KeyRichiesta, string CodArticolo)
        {
            List<UserActionLog> dbResult = new List<UserActionLog>();
            using (var dbCtx = new MoonPro_STATSContext(_configuration))
            {
                var dataFrom = new SqlParameter("@dataFrom", DataStart);
                var dataTo = new SqlParameter("@dataTo", DataEnd);
                var idxMacchina = new SqlParameter("@IdxMacchina", IdxMacchina);
                var idxODL = new SqlParameter("@IdxODL", IdxODL);
                var keyRichiesta = new SqlParameter("@KeyRichiesta", KeyRichiesta);
                var codArticolo = new SqlParameter("@CodArticolo", CodArticolo);

                dbResult = dbCtx
                    .DbSetUserLog
                    .FromSqlRaw("EXEC stp_UI_UL_GetByFilter @dataFrom,@dataTo,@IdxMacchina,@IdxODL,@KeyRichiesta,@CodArticolo", dataFrom, dataTo, idxMacchina, idxODL, keyRichiesta, codArticolo)
                    .ToList();
            }
            return dbResult;
        }

        /// <summary>
        /// Ricerca task dato tipo + num max (desc)
        /// </summary>
        /// <param name="TaskId">TaskId da cui deriva</param>
        /// <returns></returns>
        public List<TaskExecModel> TaskExecGetFilt(int TaskId, int maxRec)
        {
            List<TaskExecModel> dbResult = new List<TaskExecModel>();
            using (var dbCtx = new MoonPro_STATSContext(_configuration))
            {
                dbResult = dbCtx
                    .DbSetTaskExe
                    .Include(x => x.TaskListNav)
                    .Where(x => (x.TaskId == TaskId))
                    .OrderByDescending(x => x.DtStart)
                    .Take(maxRec)
                    .ToList();
            }
            return dbResult;
        }

        /// <summary>
        /// Upsert record TaskExec
        /// </summary>
        /// <param name="rec2upd">Record da aggiornare/inserire</param>
        /// <returns></returns>
        public bool TaskExecUpsert(TaskExecModel rec2upd)
        {
            bool done = false;
            using (var dbCtx = new MoonPro_STATSContext(_configuration))
            {
                try
                {
                    var currData = dbCtx
                        .DbSetTaskExe
                        .Where(x => x.TaskExecId == rec2upd.TaskExecId)
                        .FirstOrDefault();
                    if (currData != null)
                    {
                        currData.TaskId = rec2upd.TaskId;
                        currData.DtStart = rec2upd.DtStart;
                        currData.DtEnd = rec2upd.DtEnd;
                        currData.IsError = rec2upd.IsError;
                        currData.Result = rec2upd.Result;
                        dbCtx.Entry(currData).State = EntityState.Modified;
                    }
                    else
                    {
                        dbCtx
                            .DbSetTaskExe
                            .Add(rec2upd);
                    }
                    dbCtx.SaveChanges();
                    done = true;
                }
                catch (Exception exc)
                {
                    Log.Error($"Eccezione in TaskExecUpsert{Environment.NewLine}{exc}");
                }
            }
            return done;
        }

        /// <summary>
        /// Ricerca task dato tipo e
        /// </summary>
        /// <param name="TType"></param>
        /// <returns></returns>
        public List<TaskListModel> TaskListGetAll(Task2ExeType TType)
        {
            List<TaskListModel> dbResult = new List<TaskListModel>();
            using (var dbCtx = new MoonPro_STATSContext(_configuration))
            {
                dbResult = dbCtx
                    .DbSetTaskList
                    .Where(x => (TType == Task2ExeType.ND || x.TType == TType))
                    .OrderBy(x => x.Ordinal)
                    .ToList();
            }
            return dbResult;
        }

        /// <summary>
        /// Update ordinamento task
        /// </summary>
        /// <param name="rec2upd">Record da spostare x priorità</param>
        /// <returns></returns>
        public bool TaskListMove(TaskListModel rec2upd, bool moveUp)
        {
            bool done = false;
            using (var dbCtx = new MoonPro_STATSContext(_configuration))
            {
                try
                {
                    var currData = dbCtx
                                    .DbSetTaskList
                                    .Where(x => x.TaskId == rec2upd.TaskId)
                                    .FirstOrDefault();
                    if (currData != null)
                    {
                        int actOrdinal = currData.Ordinal;
                        TaskListModel? otherRec = null;
                        // cerco, secondo richiesta, precedente o successivo
                        if (moveUp)
                        {
                            otherRec = dbCtx
                                        .DbSetTaskList
                                        .Where(x => x.Ordinal < currData.Ordinal)
                                        .OrderByDescending(x => x.Ordinal)
                                        .FirstOrDefault();
                        }
                        else
                        {
                            otherRec = dbCtx
                                        .DbSetTaskList
                                        .Where(x => x.Ordinal > currData.Ordinal)
                                        .OrderBy(x => x.Ordinal)
                                        .FirstOrDefault();
                        }
                        // inverto ordinale SE ho record
                        if (otherRec != null)
                        {
                            currData.Ordinal = otherRec.Ordinal;
                            otherRec.Ordinal = actOrdinal;
                            dbCtx.Entry(currData).State = EntityState.Modified;
                            dbCtx.Entry(otherRec).State = EntityState.Modified;
                        }
                    }
                    //salvo
                    dbCtx.SaveChanges();
                    done = true;
                }
                catch (Exception exc)
                {
                    Log.Error($"Eccezione in TaskListUpsert{Environment.NewLine}{exc}");
                }
            }
            return done;
        }

        /// <summary>
        /// Upsert record TaskList
        /// </summary>
        /// <param name="rec2upd">Record da aggiornare/inserire</param>
        /// <returns></returns>
        public bool TaskListUpsert(TaskListModel rec2upd)
        {
            bool done = false;
            using (var dbCtx = new MoonPro_STATSContext(_configuration))
            {
                try
                {
                    var currData = dbCtx
                        .DbSetTaskList
                        .Where(x => x.TaskId == rec2upd.TaskId)
                        .FirstOrDefault();
                    if (currData != null)
                    {
                        currData.Ordinal = rec2upd.Ordinal;
                        currData.Name = rec2upd.Name;
                        currData.Descript = rec2upd.Descript;
                        currData.Command = rec2upd.Command;
                        currData.Args = rec2upd.Args;
                        currData.Freq = rec2upd.Freq;
                        currData.Cad = rec2upd.Cad;
                        currData.DtLastExec = rec2upd.DtLastExec;
                        currData.DtNextExec = rec2upd.DtNextExec;
                        currData.LastDuration = rec2upd.LastDuration;
                        currData.LastResult = rec2upd.LastResult;
                        dbCtx.Entry(currData).State = EntityState.Modified;
                    }
                    else
                    {
                        dbCtx
                            .DbSetTaskList
                            .Add(rec2upd);
                    }
                    dbCtx.SaveChanges();
                    done = true;
                }
                catch (Exception exc)
                {
                    Log.Error($"Eccezione in TaskListUpsert{Environment.NewLine}{exc}");
                }
            }
            return done;
        }

        #endregion Public Methods

        #region Private Fields

        private static IConfiguration _configuration;

        private static NLog.Logger Log = LogManager.GetCurrentClassLogger();

        #endregion Private Fields
    }
}