using Microsoft.Data.SqlClient;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
using MP.Data.DbModels;
using MP.Data.DTO;
using MP.Data.Objects;
using NLog;
using System;
using System.Collections.Generic;
using System.Data;
using System.Diagnostics;
using System.Linq;
using System.Threading.Tasks;
using static EgwCoreLib.Utils.DtUtils;

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

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

        #endregion Public Constructors

        #region Public Methods

        /// <summary>
        /// Elenco Gruppi tipo Azienda
        /// </summary>
        /// <returns></returns>
        public List<AnagGruppi> AnagGruppiAziende()
        {
            return AnagGruppiGetTipo("AZIENDA");
        }

        /// <summary>
        /// Elenco Gruppi tipo Fasi
        /// </summary>
        /// <returns></returns>
        public List<AnagGruppi> AnagGruppiFase()
        {
            return AnagGruppiGetTipo("FASE");
        }

        /// <summary>
        /// Elenco Gruppi
        /// </summary>
        /// <returns></returns>
        public List<AnagGruppi> AnagGruppiGetAll()
        {
            List<AnagGruppi> dbResult = new List<AnagGruppi>();
            using (var dbCtx = new MoonProContext(_configuration))
            {
                dbResult = dbCtx
                            .DbSetAnagGruppi
                            .AsNoTracking()
                            .OrderBy(x => x.CodGruppo)
                            .ToList();
            }
            return dbResult;
        }

        /// <summary>
        /// Gruppi x tipo
        /// </summary>
        /// <param name="tipoGruppo"></param>
        /// <returns></returns>
        public List<AnagGruppi> AnagGruppiGetTipo(string tipoGruppo)
        {
            List<AnagGruppi> dbResult = new List<AnagGruppi>();
            using (var dbCtx = new MoonProContext(_configuration))
            {
                dbResult = dbCtx
                .DbSetAnagGruppi
                .Where(x => x.TipoGruppo == tipoGruppo)
                .AsNoTracking()
                .OrderBy(x => x.CodGruppo)
                .ToList();
            }
            return dbResult;
        }

        /// <summary>
        /// Elenco Gruppi
        /// </summary>
        /// <returns></returns>
        public List<AnagKeyValueModel> AnagKeyValGetAll()
        {
            List<AnagKeyValueModel> dbResult = new List<AnagKeyValueModel>();
            using (var dbCtx = new MoonProContext(_configuration))
            {
                dbResult = dbCtx
                            .DbSetAKV
                            .AsNoTracking()
                            .OrderBy(x => x.nomeVar)
                            .ToList();
            }
            return dbResult;
        }

        /// <summary>
        /// Elenco valori ammessi x Stati commessa (es Yacht Baglietto)
        /// </summary>
        /// <returns></returns>
        public List<ListValues> AnagStatiComm()
        {
            return ListValuesFilt("PODL", "StatoComm");
        }

        /// <summary>
        /// Elenco valori ammessi x Tipo articoli
        /// </summary>
        /// <returns></returns>
        public List<ListValues> AnagTipoArtLV()
        {
            return ListValuesFilt("AnagArticoli", "Tipo");
        }

        /// <summary>
        /// Elenco codice articoli che abbiano dati Dossier
        /// </summary>
        /// <returns></returns>
        public List<string> ArticleWithDossier()
        {
            List<string> dbResult = new List<string>();
            using (var dbCtx = new MoonPro_FluxContext(_configuration))
            {
                dbResult = dbCtx
                            .DbSetDossiers
                            .AsNoTracking()
                            .Select(i => i.CodArticolo)
                            .Distinct()
                            .ToList();
            }
            return dbResult;
        }

        /// <summary>
        /// Eliminazione Record
        /// </summary>
        /// <param name="currRec"></param>
        /// <returns></returns>
        public async Task<bool> ArticoliDeleteRecord(AnagArticoli currRec)
        {
            bool fatto = false;
            using (var dbCtx = new MoonProContext(_configuration))
            {
                try
                {
                    var currVal = dbCtx
                                    .DbSetArticoli
                                    .Where(x => x.CodArticolo == currRec.CodArticolo)
                                    .FirstOrDefault();
                    dbCtx
                        .DbSetArticoli
                        .Remove(currVal);
                    await dbCtx.SaveChangesAsync();
                    fatto = true;
                }
                catch (Exception exc)
                {
                    Log.Error($"Eccezione durante ArticoliDeleteRecord{Environment.NewLine}{exc}");
                }
            }
            return fatto;
        }

        /// <summary>
        /// Elenco tabella Articoli da filtro
        /// </summary>
        /// <param name="numRecord"></param>
        /// <param name="searchVal"></param>
        /// <returns></returns>
        public List<AnagArticoli> ArticoliGetSearch(int numRecord, string searchVal = "")
        {
            List<AnagArticoli> dbResult = new List<AnagArticoli>();
            using (var dbCtx = new MoonProContext(_configuration))
            {
                dbResult = dbCtx
                .DbSetArticoli
                .AsNoTracking()
                .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;
        }

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

        /// <summary>
        /// Elenco tabella Articoli IMPIEGATI (da stored stp_ART_getUsed)
        /// </summary>
        /// <returns></returns>
        public List<AnagArticoli> ArticoliGetUsed()
        {
            List<AnagArticoli> dbResult = new List<AnagArticoli>();
            using (var dbCtx = new MoonProContext(_configuration))
            {
                dbResult = dbCtx
                    .DbSetArticoli
                    .FromSqlRaw("EXEC stp_ART_getUsed")
                    .AsNoTracking()
                    .ToList();
            }
            return dbResult;
        }

        /// <summary>
        /// Update Record
        /// </summary>
        /// <param name="currRec"></param>
        /// <returns></returns>
        public async Task<bool> ArticoliUpdateRecord(AnagArticoli editRec)
        {
            bool fatto = false;
            using (var dbCtx = new MoonProContext(_configuration))
            {
                try
                {
                    var currRec = dbCtx
                                    .DbSetArticoli
                                    .Where(x => x.CodArticolo == editRec.CodArticolo)
                                    .FirstOrDefault();
                    if (currRec != null)
                    {
                        currRec.Disegno = editRec.Disegno;
                        currRec.DescArticolo = editRec.DescArticolo;
                        currRec.Tipo = editRec.Tipo;
                        currRec.Azienda = editRec.Azienda;
                        dbCtx.Entry(currRec).State = EntityState.Modified;
                    }
                    else
                    {
                        dbCtx
                            .DbSetArticoli
                            .Add(editRec);
                    }
                    await dbCtx.SaveChangesAsync();
                    fatto = true;
                }
                catch (Exception exc)
                {
                    Log.Error($"Eccezione durante ArticoliUpdateRecord{Environment.NewLine}{exc}");
                }
            }
            return fatto;
        }

        /// <summary>
        /// Elenco da tabella Config
        /// </summary>
        /// <returns></returns>
        public List<ConfigModel> ConfigGetAll()
        {
            List<ConfigModel> dbResult = new List<ConfigModel>();
            using (var dbCtx = new MoonProContext(_configuration))
            {
                dbResult = dbCtx
                .DbSetConfig
                .AsNoTracking()
                .OrderBy(x => x.Chiave)
                .ToList();
            }
            return dbResult;
        }

        /// <summary>
        /// Update record config
        /// </summary>
        /// <returns></returns>
        public bool ConfigUpdate(ConfigModel updRec)
        {
            bool fatto = false;
            ConfigModel dbResult = new ConfigModel();
            using (var dbCtx = new MoonProContext(_configuration))
            {
                dbResult = dbCtx
                .DbSetConfig
                .Where(x => x.Chiave == updRec.Chiave)
                .FirstOrDefault();
                if (dbResult != null)
                {
                    dbResult.Valore = updRec.Valore;
                    dbCtx.SaveChanges();
                    fatto = true;
                }
            }
            return fatto;
        }

        /// <summary>
        /// Intera tab dati macchina
        /// </summary>
        /// <returns></returns>
        public List<DatiMacchineModel> DatiMacchineGetAll()
        {
            List<DatiMacchineModel> dbResult = new List<DatiMacchineModel>();
            using (var dbCtx = new MoonProContext(_configuration))
            {
                dbResult = dbCtx
                            .DbSetDatiMacchine
                            .AsNoTracking()
                            .OrderBy(x => x.IdxMacchina)
                            .ToList();
            }
            return dbResult;
        }

        public void Dispose()
        {
            _configuration = null;
        }

        /// <summary>
        /// Eliminazione di un dossier
        /// </summary>
        /// <param name="currRec">record dossier da eliminare</param>
        /// <returns></returns>
        public async Task<bool> DossiersDeleteRecord(DossierModel currRec)
        {
            bool answ = false;
            using (var dbCtx = new MoonPro_FluxContext(_configuration))
            {
                try
                {
                    var currVal = dbCtx
                                .DbSetDossiers
                                .Where(x => x.IdxDossier == currRec.IdxDossier)
                                .FirstOrDefault();
                    dbCtx
                        .DbSetDossiers
                        .Remove(currVal);
                    await dbCtx.SaveChangesAsync();
                    answ = true;
                }
                catch (Exception exc)
                {
                    Log.Error($"Eccezione durante DossiersDeleteRecord{Environment.NewLine}{exc}");
                }
            }
            return answ;
        }

        /// <summary>
        /// Elenco ultimi n record DOssiers (che contengono ad esempio "salvataggi" di FLuxLog) dato
        /// macchina (ordinato x data registrazione)
        /// </summary>
        /// <param name="IdxMacchina">* = tutte, altrimenti solo x una data macchina</param>
        /// <param name="CodArticolo">* = tutti, altrimenti solo x un dato articolo</param>
        /// <param name="DtStart">Data minima per estrazione records</param>
        /// <param name="DtEnd">Data Massima per estrazione records</param>
        /// <returns></returns>
        public List<DossierModel> DossiersGetLastFilt(string IdxMacchina, string CodArticolo, DateTime DtStart, DateTime DtEnd)
        {
            List<DossierModel> dbResult = new List<DossierModel>();
            using (var dbCtx = new MoonPro_FluxContext(_configuration))
            {
                dbResult = dbCtx
                            .DbSetDossiers
                            .AsNoTracking()
                            .Where(x => (IdxMacchina == "*" || x.IdxMacchina == IdxMacchina) && (CodArticolo == "*" || x.CodArticolo == CodArticolo) && (x.DtRif >= DtStart && x.DtRif <= DtEnd))
                            .Include(m => m.MachineNav)
                            .Include(a => a.ArticoloNav)
                            ////.Include(o => o.OdlNav)
                            .OrderByDescending(x => x.DtRif)
                            .ToList();
            }
            return dbResult;
        }

        /// <summary>
        /// insert di un record Dossier
        /// </summary>
        /// <param name="editRec">record dossier da modificare</param>
        /// <returns></returns>
        public async Task<bool> DossiersInsert(DossierModel newRec)
        {
            bool fatto = false;
            using (var dbCtx = new MoonPro_FluxContext(_configuration))
            {
                try
                {
                    dbCtx
                        .DbSetDossiers
                        .Add(newRec);
                    await dbCtx.SaveChangesAsync();
                    fatto = true;
                }
                catch (Exception exc)
                {
                    Log.Error($"Eccezione durante DossiersInsert{Environment.NewLine}{exc}");
                }
            }
            return fatto;
        }

        /// <summary>
        /// Effettua salvataggio snapshot parametri (con stored) + svuota eventuale cache redis
        /// </summary>
        /// <param name="idxMacchina">macchina</param>
        /// <param name="maxSec">Num massimo secondi per recuperare dati correnti</param>
        /// <param name="dtRif">DataOra riferimento x cui prendere valori antecedenti</param>
        public bool DossiersTakeParamsSnapshot(string idxMacchina, int maxSec, DateTime dtRif)
        {
            bool answ = false;
            using (var dbCtx = new MoonPro_FluxContext(_configuration))
            {
                var pIdxMacchina = new SqlParameter("@IdxMacchina", idxMacchina);
                var pMaxSec = new SqlParameter("@MaxSec", maxSec);
                var pDtRif = new SqlParameter("@DtRif", dtRif);

                var dbResult = dbCtx
                    .Database
                    .ExecuteSqlRaw("EXEC stp_FL_TakeSnapshot @IdxMacchina,@MaxSec,@DtRif", pIdxMacchina, pMaxSec, pDtRif);
                answ = true;
            }
            return answ;
        }

        /// <summary>
        /// Effettua salvataggio snapshot parametri (con stored) + svuota eventuale cache redis
        /// </summary>
        /// <param name="idxMacchina">macchina</param>
        /// <param name="dtMin">Data min x selezione</param>
        /// <param name="dtMax">Data MAX x selezione</param>
        public bool DossiersTakeParamsSnapshotLast(string idxMacchina, DateTime dtMin, DateTime dtMax)
        {
            bool answ = false;
            using (var dbCtx = new MoonPro_FluxContext(_configuration))
            {
                var pIdxMacchina = new SqlParameter("@IdxMacchina", idxMacchina);
                var pDtMin = new SqlParameter("@DtMin", dtMin);
                var pDtMax = new SqlParameter("@DtMax", dtMax);

                var dbResult = dbCtx
                    .Database
                    .ExecuteSqlRaw("EXEC stp_FL_TakeSnapshotLast @IdxMacchina,@DtMin,@DtMax", pIdxMacchina, pDtMin, pDtMax);
                answ = true;
            }
            return answ;
        }

        /// <summary>
        /// Update del campo VALORE di un dossier (che contiene json flux log serializzati)
        /// </summary>
        /// <param name="editRec">record dossier da modificare</param>
        /// <returns></returns>
        public async Task<bool> DossiersUpdateValore(DossierModel editRec)
        {
            bool fatto = false;
            using (var dbCtx = new MoonPro_FluxContext(_configuration))
            {
                try
                {
                    var currRec = dbCtx
                                    .DbSetDossiers
                                    .Where(x => x.IdxDossier == editRec.IdxDossier)
                                    .FirstOrDefault();
                    if (currRec != null)
                    {
                        currRec.Valore = editRec.Valore;
                        dbCtx.Entry(currRec).State = EntityState.Modified;
                    }
                    else
                    {
                        dbCtx
                            .DbSetDossiers
                            .Add(editRec);
                    }
                    await dbCtx.SaveChangesAsync();
                    fatto = true;
                }
                catch (Exception exc)
                {
                    Log.Error($"Eccezione durante DossiersUpdateRecord{Environment.NewLine}{exc}");
                }
            }
            return fatto;
        }

        /// <summary>
        /// Elenco valori link (x home e navMenu laterale)
        /// </summary>
        /// <returns></returns>
        public List<LinkMenu> ElencoLink()
        {
            return ListLinkFilt("SpecLink");
        }

        /// <summary>
        /// Aggiunta record EventList
        /// </summary>
        /// <param name="newRec"></param>
        /// <returns></returns>
        public async Task<bool> EvListInsert(EventListModel newRec)
        {
            bool fatto = false;
            using (var dbCtx = new MoonProContext(_configuration))
            {
                try
                {
                    var currRec = dbCtx
                                    .DbSetEvList
                                    .Add(newRec);
                    await dbCtx.SaveChangesAsync();
                }
                catch (Exception exc)
                {
                    Log.Error($"Eccezione durante EvListInsert{Environment.NewLine}{exc}");
                }
            }
            await Task.Delay(1);
            return fatto;
        }

        /// <summary>
        /// Funzione di Data Reduction x FluxLog
        /// </summary>
        /// <param name="idxMaccSel"></param>
        /// <param name="fluxList"></param>
        /// <param name="currPeriodo"></param>
        /// <param name="valMode"></param>
        /// <param name="intReq"></param>
        /// <returns>
        /// Restitusice list dei record statistiche raccolti (da integrare a quelli rpesenti in Redis...)
        /// </returns>
        public async Task<List<StatDedupDTO>> FluxLogDataRedux(string idxMaccSel, List<string> fluxList, Periodo currPeriodo, Enums.ValSelection valMode, Enums.DataInterval intReq, int maxItem)
        {
            List<StatDedupDTO> procStats = new List<StatDedupDTO>();
            Log.Info($"Inizio FluxLogDataRedux | idxMaccSel: {idxMaccSel} | periodo: {currPeriodo.Inizio:yyyy-MM-dd} --> {currPeriodo.Fine:yyyy-MM-dd}");
            TimeSpan step = TimeSpan.FromHours(1);
            switch (intReq)
            {
                case Enums.DataInterval.minute:
                    step = TimeSpan.FromMinutes(1.00 / maxItem);
                    break;

                case Enums.DataInterval.hour:
                    step = TimeSpan.FromHours(1.00 / maxItem);
                    break;

                case Enums.DataInterval.day:
                    step = TimeSpan.FromDays(1.00 / maxItem);
                    break;

                default:
                    break;
            }

            // setup parametri costanti x stored
            var pIdxMacchina = new SqlParameter("@IdxMacchina", idxMaccSel);
            var pOnlyTest = new SqlParameter("@OnlyTest", false);

            // processo 1:1 ogni flusso
            foreach (var item in fluxList)
            {
                Log.Info($"FluxLogDataRedux | Flux: {item}");
                int numRecProc = 0;
                Stopwatch sw = new Stopwatch();
                sw.Start();
                // parametri x flusso
                var pCodFlux = new SqlParameter("@CodFlux", item);
                // inizializzo cursore timer
                DateTime dtCursStart = currPeriodo.Inizio;
                DateTime dtCursEnd = dtCursStart.Add(step);
                bool setCompleted = false;
                // dbContext x ogni singolo flusso
                using (var dbCtx = new MoonPro_FluxContext(_configuration))
                {
                    // opzionalmente timeout comandi a 2 minuti... NON usato x ora e da testare
                    //dbCtx.Database.SetCommandTimeout(TimeSpan.FromMinutes(2));
                    // li processo per intervallo richiesto, cercando dati nel periodo e
                    // selezionando VC
                    while (!setCompleted)
                    {
                        // ora recupero TUTTI i dati della macchina
                        var currFlux = await dbCtx
                                 .DbSetFluxLog
                                 .Where(x => (x.CodFlux == item) && (x.dtEvento >= dtCursStart && x.dtEvento < dtCursEnd) && (x.IdxMacchina == idxMaccSel))
                                 .ToListAsync();

                        int numRec = currFlux.Count;
                        numRecProc += numRec;
                        if (numRec > maxItem)
                        {
                            List<Periodo> listPeriodi = new List<Periodo>();

                            switch (valMode)
                            {
                                case Enums.ValSelection.First:
                                    // recupero 2° item
                                    var recStart = currFlux.Skip(1).FirstOrDefault();
                                    // salvo periodo!
                                    listPeriodi.Add(new Periodo(recStart.dtEvento, dtCursEnd));
                                    break;

                                case Enums.ValSelection.Last:
                                    // recupero ultimo item
                                    var recEnd = currFlux.LastOrDefault();
                                    // salvo periodo!
                                    listPeriodi.Add(new Periodo(dtCursStart, recEnd.dtEvento));
                                    break;

                                case Enums.ValSelection.Center:
                                    int idx = 1;
                                    // per iniziare mi metto a 1/(n+1) rec come step
                                    var recCent = currFlux.Skip(idx / (maxItem + 1)).FirstOrDefault();
                                    listPeriodi.Add(new Periodo(dtCursStart, recCent.dtEvento));
                                    // salvo restanti periodi (se > 1)!
                                    if (maxItem > 1)
                                    {
                                        for (int i = 2; i < maxItem; i++)
                                        {
                                            DateTime dtInizio = recCent.dtEvento;
                                            recCent = currFlux.Skip(i / (maxItem + 1)).FirstOrDefault();
                                            listPeriodi.Add(new Periodo(dtInizio, recCent.dtEvento));
                                        }
                                    }
                                    // aggiungo ultimo...
                                    listPeriodi.Add(new Periodo(recCent.dtEvento.AddSeconds(1), dtCursEnd));
                                    break;

                                default:
                                    break;
                            }

                            // ciclo x tutti i periodi e chiamo stored...
                            foreach (var slot in listPeriodi)
                            {
                                // parametri x periodo (base)
                                var pDtStart = new SqlParameter("@DtStart", slot.Inizio);
                                var pDtEnd = new SqlParameter("@DtEnd", slot.Fine);
                                var dbResult = dbCtx
                                        .Database
                                        .ExecuteSqlRaw("EXEC man.stp_ReduceFluxLog @IdxMacchina, @CodFlux, @DtStart, @DtEnd, @OnlyTest", pIdxMacchina, pCodFlux, pDtStart, pDtEnd, pOnlyTest);
                            }
                        }

                        // incremento dt fine periodo
                        dtCursStart = dtCursEnd;
                        dtCursEnd = dtCursStart.Add(step);
                        setCompleted = dtCursStart >= currPeriodo.Fine;
                    }
                }
                // fermo cronometro e salvo su DB...
                sw.Stop();
                StatDedupDTO currStat = new StatDedupDTO()
                {
                    IdxMacchina = idxMaccSel,
                    CodFlux = item,
                    Interval = intReq,
                    Num4Int = maxItem,
                    NumRec = numRecProc,
                    ProcTime = sw.Elapsed.TotalSeconds
                };
                procStats.Add(currStat);
            }
            Log.Info($"FINE FluxLogDataRedux | idxMaccSel: {idxMaccSel} | periodo: {currPeriodo.Inizio:yyyy-MM-dd} --> {currPeriodo.Fine:yyyy-MM-dd}");
            return procStats;
        }

        /// <summary>
        /// Elenco ultimi n record flux log dato macchina e flusso (ordinato x data registrazione)
        /// </summary>
        /// <param name="DtMax">Data massima x eventi</param>
        /// <param name="DtMin">Data minima x eventi</param>
        /// <param name="IdxMacchina">* = tutte, altrimenti solo x una data macchina</param>
        /// <param name="CodFlux">*=tutti, altrimenti solo selezionato</param>
        /// <param name="MaxRec">numero massimo record da restituire</param>
        /// <returns></returns>
        public List<FluxLogModel> FluxLogGetLastFilt(DateTime DtMax, DateTime DtMin, string IdxMacchina, string CodFlux, int MaxRec)
        {
            List<FluxLogModel> dbResult = new List<FluxLogModel>();
            using (var dbCtx = new MoonPro_FluxContext(_configuration))
            {
                dbResult = dbCtx
                            .DbSetFluxLog
                            .AsNoTracking()
                            .Where(x => (x.dtEvento >= DtMin && x.dtEvento <= DtMax) && (IdxMacchina == "*" || x.IdxMacchina == IdxMacchina) && (CodFlux == "*" || x.CodFlux == CodFlux))
                            .OrderByDescending(x => x.dtEvento)
                            .Take(MaxRec)
                            .ToList();
            }
            return dbResult;
        }

        /// <summary>
        /// Elenco Gruppi
        /// </summary>
        /// <returns></returns>
        public List<ParetoFluxLogDTO> FluxLogPareto(string idxMacchina, DateTime dtFrom, DateTime dtTo)
        {
            List<ParetoFluxLogDTO> dbResult = new List<ParetoFluxLogDTO>();
            using (var dbCtx = new MoonPro_FluxContext(_configuration))
            {
                dbResult = dbCtx
                            .DbSetFluxLog
                            .Where(x => (string.IsNullOrEmpty(idxMacchina) || x.IdxMacchina == idxMacchina) && (dtFrom <= x.dtEvento && x.dtEvento <= dtTo))
                            .AsNoTracking()
                            .GroupBy(x => x.CodFlux)
                            .Select(g => new ParetoFluxLogDTO() { IdxMacchina = idxMacchina, CodFlux = g.Key, Qty = g.Count() })
                            .OrderByDescending(x => x.Qty)
                            .ToList();
            }
            return dbResult;
        }

        /// <summary>
        /// Stored manutenzione del DB
        /// </summary>
        /// <param name="doExec">Esegue realmente il task</param>
        /// <param name="doUpdStat">Aggiornamento statistiche</param>
        /// <param name="doSave">Salvataggio</param>
        /// <param name="minPgCnt">def: 1000</param>
        /// <param name="minAvgFrag">def: 10</param>
        /// <param name="maxAvgFragReb">def: 50</param>
        /// <returns></returns>
        public async Task<bool> ForceDbMaint(bool doExec, bool doUpdStat, bool doSave, int minPgCnt, int minAvgFrag, int maxAvgFragReb)
        {
            Log.Info($"Inizio ForceDbMaint on MoonProAdminContext");
            bool fatto = false;
            // uso context admin x query lunghe
            using (var dbCtx = new MoonProAdminContext(_configuration))
            {
                var pFlgExec = new SqlParameter("@FlgExec", doExec ? "Y" : "N");
                var pFlgUpdStat = new SqlParameter("@FlgUpdStat", doUpdStat ? "Y" : "N");
                var pFlgSave = new SqlParameter("@FlgSave", doSave ? "Y" : "N");
                var pMinPgCnt = new SqlParameter("@min_page_count", minPgCnt);
                var pMinAvgFrag = new SqlParameter("@min_avg_fragmentation_in_percent", minAvgFrag);
                var pMaxAvgFrag = new SqlParameter("@max_avg_fragmentation_per_rebuild", maxAvgFragReb);

                var dbResult = await dbCtx
                        .Database
                        .ExecuteSqlRawAsync("EXEC man.stp_Utility_Maintanance");
                //.ExecuteSqlRaw("EXEC man.stp_Utility_Maintanance @FlgExec, @FlgUpdStat, @FlgSave, @min_page_count, @min_avg_fragmentation_in_percent, @max_avg_fragmentation_per_rebuild", pFlgExec, pFlgUpdStat, pFlgSave, pMinPgCnt, pMinAvgFrag, pMaxAvgFrag);
                fatto = true;
            }
            Log.Info($"FINE ForceDbMaint on MoonProAdminContext");
            return fatto;
        }

        /// <summary>
        /// Elenco giacenze
        /// </summary>
        /// <param name="IdxOdl">id odl da cercare</param>
        /// <returns></returns>
        public List<AnagGiacenzeModel> ListGiacenze(int IdxOdl)
        {
            List<AnagGiacenzeModel> dbResult = new List<AnagGiacenzeModel>();
            using (var dbCtx = new MoonPro_InveContext(_configuration))
            {
                try
                {
                    dbResult = dbCtx
                                .DbGiacenzeData
                                .AsNoTracking()
                                .Where(x => x.IdxOdl == IdxOdl)
                                .ToList();
                }
                catch (Exception exc)
                {
                    Log.Error($"Eccezione durante ListGiacenze{Environment.NewLine}{exc}");
                }
            }
            return dbResult;
        }

        /// <summary>
        /// Elenco link JQM completo
        /// </summary>
        /// <param name="tipoLink"></param>
        /// <returns></returns>
        public List<LinkMenu> ListLinkAll()
        {
            List<LinkMenu> dbResult = new List<LinkMenu>();
            using (var dbCtx = new MoonProContext(_configuration))
            {
                dbResult = dbCtx
                            .DbSetLinkMenu
                            .AsNoTracking()
                            .OrderBy(x => x.ordine)
                            .ToList();
            }
            return dbResult;
        }

        /// <summary>
        /// Elenco link JQM dato filtro tipo
        /// </summary>
        /// <param name="tipoLink"></param>
        /// <returns></returns>
        public List<LinkMenu> ListLinkFilt(string tipoLink)
        {
            List<LinkMenu> dbResult = new List<LinkMenu>();
            using (var dbCtx = new MoonProContext(_configuration))
            {
                dbResult = dbCtx
                            .DbSetLinkMenu
                            .Where(x => x.TipoLink == tipoLink)
                            .AsNoTracking()
                            .OrderBy(x => x.ordine)
                            .ToList();
            }
            return dbResult;
        }

        /// <summary>
        /// Elenco ODL filtrati x stato, articolo, KeyRich (che contiene stato)
        /// </summary>
        /// <param name="inCorso">Stato ODL: true=in corso/completato</param>
        /// <param name="codArt">Cod articolo</param>
        /// <param name="keyRichPart">KeyRich (parziale) da cercare (es cod stato x yacht)</param>
        /// <param name="Reparto">Reparto selezionato</param>
        /// <param name="IdxMacchina">Macchina selezionata</param>
        /// <param name="startDate">Data inizio</param>
        /// <param name="endDate">Data fine</param>
        /// <returns></returns>
        public List<ODLExpModel> ListODLFilt(bool inCorso, string codArt, string keyRichPart, string Reparto, string IdxMacchina, DateTime startDate, DateTime endDate)
        {
            List<ODLExpModel> dbResult = new List<ODLExpModel>();
            using (var dbCtx = new MoonProContext(_configuration))
            {
                var InCorso = new SqlParameter("@InCorso", inCorso);
                var CodArt = new SqlParameter("@CodArt", codArt);
                var KeyRich = new SqlParameter("@KeyRich", keyRichPart);
                var CodGruppo = new SqlParameter("@CodGruppo", Reparto);
                var IdxMacc = new SqlParameter("@IdxMacchina", IdxMacchina);
                var DataFrom = new SqlParameter("@DataFrom", startDate);
                var DataTo = new SqlParameter("@DataTo", endDate);

                dbResult = dbCtx
                            .DbSetODLExp
                            .FromSqlRaw("EXEC stp_ODL_getByFiltSpec @InCorso, @CodArt, @KeyRich, @CodGruppo, @IdxMacchina, @DataFrom, @DataTo", InCorso, CodArt, KeyRich, CodGruppo, IdxMacc, DataFrom, DataTo)
                            .AsNoTracking()
                            .ToList();
            }
            return dbResult;
        }

        /// <summary>
        /// Elenco PODL non avviati filtrati x articolo, KeyRich (che contiene stato)
        /// </summary>
        /// <param name="lanciato">Solo lanciati (1) o ancora disponibili (0)</param>
        /// <param name="keyRichPart">KeyRich (parziale) da cercare (es cod stato x yacht)</param>
        /// <param name="idxMacchina">Macchina</param>
        /// <param name="codGruppo">Gruppo</param>
        /// <returns></returns>
        public List<PODLExpModel> ListPODLFilt(bool lanciato, string keyRichPart, string idxMacchina, string codGruppo, DateTime startDate, DateTime endDate)
        {
            List<PODLExpModel> dbResult = new List<PODLExpModel>();
            using (var dbCtx = new MoonProContext(_configuration))
            {
                var Lanc = new SqlParameter("@Lanciato", lanciato);
                var KeyRich = new SqlParameter("@KeyRich", keyRichPart);
                var CodGrp = new SqlParameter("@CodGruppo", codGruppo);
                var IdxMacc = new SqlParameter("@IdxMacchina", idxMacchina);
                var DateFrom = new SqlParameter("@DtInizio", startDate);
                var DateTo = new SqlParameter("@DtFine", endDate);

                dbResult = dbCtx
                            .DbSetPODLExp
                            .FromSqlRaw("EXEC stp_PODL_getByFiltSpec @Lanciato, @KeyRich, @CodGruppo, @IdxMacchina, @DtInizio, @DtFine", Lanc, KeyRich, CodGrp, IdxMacc, DateFrom, DateTo)
                            .AsNoTracking()
                            .ToList();
            }
            return dbResult;
        }

        /// <summary>
        /// Elenco valori ammessi x tabella/colonna
        /// </summary>
        /// <param name="tabName"></param>
        /// <param name="fieldName"></param>
        /// <returns></returns>
        public List<ListValues> ListValuesFilt(string tabName, string fieldName)
        {
            List<ListValues> dbResult = new List<ListValues>();
            using (var dbCtx = new MoonProContext(_configuration))
            {
                dbResult = dbCtx
                .DbSetListValues
                .Where(x => x.TableName == tabName && x.FieldName == fieldName)
                .AsNoTracking()
                .OrderBy(x => x.ordinal)
                .ToList();
            }
            return dbResult;
        }

        /// <summary>
        /// Elenco Macchine dato operatore secondo gruppi (macchine/operatore)
        /// </summary>
        /// <param name="MatrOpr"></param>
        /// <returns></returns>
        public List<Macchine> MacchineByMatrOper(int MatrOpr)
        {
            List<Macchine> dbResult = new List<Macchine>();
            try
            {
                using (var dbCtx = new MoonProContext(_configuration))
                {
                    if (MatrOpr == 0)
                    {
                        dbResult = dbCtx
                                    .DbSetMacchine
                                    .AsNoTracking()
                                    .OrderBy(x => x.IdxMacchina)
                                    .ToList();
                    }
                    else
                    {
                        dbResult = dbCtx
                                    .DbSetGrp2Oper
                                    .Where(g => g.MatrOpr == MatrOpr)
                                    .Join(dbCtx.DbSetGrp2Macc,
                                        g => g.CodGruppo,
                                        m => m.CodGruppo,
                                        (g, m) => m
                                    )
                                    .Distinct()
                                    .Join(dbCtx.DbSetMacchine,
                                        g => g.IdxMacchina,
                                        m => m.IdxMacchina,
                                        (g, m) => m
                                    )
                                    .Distinct()
                                    .AsNoTracking()
                                    .OrderBy(x => x.IdxMacchina)
                                    .ToList();
                    }
                }
            }
            catch (Exception exc)
            {
                Log.Error($"Eccezione in MacchineByMatrOper{Environment.NewLine}{exc}");
            }
            return dbResult;
        }

        /// <summary>
        /// Elenco da tabella Macchine
        /// </summary>
        /// <param name="codGruppo"></param>
        /// <returns></returns>
        public List<Macchine> MacchineGetFilt(string codGruppo)
        {
            List<Macchine> dbResult = new List<Macchine>();
            try
            {
                using (var dbCtx = new MoonProContext(_configuration))
                {
                    if (codGruppo == "*")
                    {
                        dbResult = dbCtx
                                    .DbSetMacchine
                                    .AsNoTracking()
                                    .OrderBy(x => x.IdxMacchina)
                                    .ToList();
                    }
                    else
                    {
                        dbResult = dbCtx
                                    .DbSetGrp2Macc
                                    .Where(g => g.CodGruppo == codGruppo)
                                    .Join(dbCtx.DbSetMacchine,
                                        g => g.IdxMacchina,
                                        m => m.IdxMacchina,
                                        (g, m) => m
                                    )
                                    .AsNoTracking()
                                    .OrderBy(x => x.IdxMacchina)
                                    .ToList();
                    }
                }
            }
            catch (Exception exc)
            {
                Log.Error($"Eccezione in MacchineGetFilt{Environment.NewLine}{exc}");
            }
            return dbResult;
        }

        /// <summary>
        /// Elenco id Macchine che abbiano dati FLuxLog, nel periodo indicato
        /// </summary>
        /// <param name="dtStart"></param>
        /// <param name="dtEnd"></param>
        /// <returns></returns>
        public async Task<List<string>> MacchineWithFlux(DateTime dtStart, DateTime dtEnd)
        {
            List<string> dbResult = new List<string>();
            using (var dbCtx = new MoonPro_FluxContext(_configuration))
            {
                dbResult = await dbCtx
                                .DbSetFluxLog
                                .AsNoTracking()
                                .Where(x => x.dtEvento >= dtStart && x.dtEvento <= dtEnd)
                                .Select(i => i.IdxMacchina)
                                .Distinct()
                                .ToListAsync();
            }
            return dbResult;
        }

        /// <summary>
        /// Elenco da tabella MappaStatoExpl
        /// </summary>
        /// <returns></returns>
        public List<MappaStatoExpl> MseGetAll(int maxAge = 2000)
        {
            List<MappaStatoExpl> dbResult = new List<MappaStatoExpl>();
            using (var dbCtx = new MoonProContext(_configuration))
            {
                var maxAgeSec = new SqlParameter("@maxAgeSec", maxAge);

                dbResult = dbCtx
                    .DbSetMSE
                    .FromSqlRaw("EXEC stp_MSE_getData @maxAgeSec", maxAgeSec)
                    .AsNoTracking()
                    .ToList();
            }
            return dbResult;
        }

        /// <summary>
        /// Elenco ODL dato batch selezionato
        /// </summary>
        /// <param name="BatchSel">Batch richiesto</param>
        /// <returns></returns>
        public List<int> OdlByBatch(string batchSel)
        {
            List<int> dbResult = new List<int>();
            using (var dbCtx = new MoonPro_InveContext(_configuration))
            {
                try
                {
                    dbResult = dbCtx
                                .DbGiacenzeData
                                .AsNoTracking()
                                .Where(x => x.IdentRG == batchSel)
                                .Select(x => x.IdxOdl)
                                .ToList();
                }
                catch (Exception exc)
                {
                    Log.Error($"Eccezione durante OdlByBatch{Environment.NewLine}{exc}");
                }
            }
            return dbResult;
        }

        /// <summary>
        /// ODL da chiave
        /// </summary>
        /// <returns></returns>
        public ODLExpModel OdlByKey(int IdxOdl)
        {
            ODLExpModel dbResult = new ODLExpModel();
            using (var dbCtx = new MoonProContext(_configuration))
            {
                try
                {
                    dbResult = dbCtx
                                .DbSetODLExp
                                .AsNoTracking()
                                .Where(x => x.IdxOdl == IdxOdl)
                                .FirstOrDefault();
                }
                catch (Exception exc)
                {
                    Log.Error($"Eccezione durante OdlByKey{Environment.NewLine}{exc}");
                }
            }
            return dbResult;
        }

        /// <summary>
        /// Chiusura ODL con eventuale conferma pezzi
        /// </summary>
        /// <param name="idxOdl">idx odl da chiudere</param>
        /// <param name="idxMacchina">idx macchina</param>
        /// <param name="matrOpr">matricola operatore</param>
        /// <param name="confPezzi">indica se confermare i pezzi prima di chiudere ODL</param>
        /// <param name="confRett">Conferma con rettifica (ev 121) x pezzi lasciati in macchina</param>
        /// <param name="modoConfProd">Modo conferma produzione (0=periodo, 1=giorno, 2=turno)</param>
        /// <returns></returns>
        public async Task<bool> ODLClose(int idxOdl, string idxMacchina, int matrOpr, bool confPezzi, bool confRett, int modoConfProd)
        {
            bool fatto = false;
            await Task.Delay(1);
            if (idxOdl > 0)
            {
                using (var dbCtx = new MoonProContext(_configuration))
                {
                    DateTime adesso = DateTime.Now;
                    // preparo i parametri
                    var IdxODL = new SqlParameter("@IdxODL", idxOdl);
                    var IdxMacchina = new SqlParameter("@IdxMacchina", idxMacchina);

                    // FARE FIXME TODO !!! da valutare casi setup/autoconferma...
#if false
                    // controllo se HO pezzi da confermare...
                    var statoProd = StatoProdMacchina(idxMacchina);
                    if (statoProd.pezziNonConfermati < 1)
                    { }
#endif

                    // se richiesto confermo produzione
                    if (confPezzi)
                    {
                        var MatrApp = new SqlParameter("@MatrApp", idxMacchina);

                        /* ----------------------------------
                         * CONFERMA PEZZI
                         *
                         * condizioni da verificare:
                         * - gestione rettifica (ev121) / pezzi da LASCIARE in macchina
                         * - conferma a zero pezzi (setup) oppure con i pezzi fatti e non ancora confermati
                         *
                         *
                         *
                         * */

                        // recupero i dati dei pezzi da confermare... con DbSetPzProd + exec
                        // stp_PzProd_getByMacchina 'SIMUL_01'

                        // stp_ConfermaProduzCompletaFull
                        /*
                         *  @idxMacchina    NVARCHAR(50),
                            @MatrApp        INT,
                            @dataFrom       DATETIME,
                            @dataTo         DATETIME,
                            @pezziConf      INT,
                            @pezziLasciati  INT,				-- pezzi lasciati = evento 121 (-) pre conferma e (+) dopo --> da lasciare in macchina post conferma
                            @pezziScar      INT = 0,            -- pezzi scartati (registrati da 2016.11.20) DA INDICARE COME VALORE > 0!!! sennò faccio ABS...
                            @TipoConf       INT = 0,            -- Tipo intervallo conferma: 0 = periodo intero, 1 = per giorni, 2 = per turni
                            @DataOraApp     DATETIME = NULL,    -- di norma GETDATE() nel programma - serve per ricalcolo
                            @TestConferma   BIT = 1             -- TestConferma : 1 = verifica conf. duplicata e inserisci in ElencoConfermeProd, 0 = nessuna verifica e inserimento ( per ricalcolo )
                         */
                    }

                    // ora chiudo ODL con stored SENZA ritorno...
                    try
                    {
                        var dbResult = dbCtx
                            .Database
                            .ExecuteSqlRaw("EXEC stp_ODL_fineProd @IdxODL, @IdxMacchina", IdxODL, IdxMacchina);
                        fatto = true;
                    }
                    catch (Exception exc)
                    {
                        Log.Error($"Eccezione durante ODLClose{Environment.NewLine}{exc}");
                    }
                }
            }
            return fatto;
        }

        /// <summary>
        /// Recupero odl data chiave
        /// </summary>
        /// <param name="idxOdl"></param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        public ODLModel OdlGetByKey(int idxOdl)
        {
            ODLModel dbResult = new ODLModel();

            using (var dbCtx = new MoonProContext(_configuration))
            {
                dbResult = dbCtx
                            .DbSetODL
                            .FirstOrDefault(x => x.IdxOdl == idxOdl);
            }
            return dbResult;
        }

        /// <summary>
        /// Recupero Odl CORRENTI
        /// </summary>
        /// <returns></returns>
        public List<ODLModel> OdlGetCurrent()
        {
            List<ODLModel> dbResult = new List<ODLModel>();
            using (var dbCtx = new MoonProContext(_configuration))
            {
                dbResult = dbCtx
                            .DbSetODL
                            .Where(x => x.DataInizio != null && x.DataFine == null)
                            .ToList();
            }
            return dbResult;
        }

        /// <summary>
        /// Elenco TUTTI GLI ODL
        /// </summary>
        /// <returns></returns>
        public List<ODLModel> OdlListAll()
        {
            List<ODLModel> dbResult = new List<ODLModel>();
            using (var dbCtx = new MoonProContext(_configuration))
            {
                try
                {
                    dbResult = dbCtx
                                .DbSetODL
                                .AsNoTracking()
                                .ToList();
                }
                catch (Exception exc)
                {
                    Log.Error($"Eccezione durante ListOdlAll{Environment.NewLine}{exc}");
                }
            }
            return dbResult;
        }

        /// <summary>
        /// Statistiche ODL calcolate (da stored stp_STAT_ODL)
        /// </summary>
        /// <returns></returns>
        public async Task<List<StatODLModel>> OdlStart(int IdxOdl)
        {
            List<StatODLModel> dbResult = new List<StatODLModel>();
            if (IdxOdl > 0)
            {
                using (var dbCtx = new MoonProContext(_configuration))
                {
                    var IdxODL = new SqlParameter("@IdxODL", IdxOdl);

                    dbResult = await dbCtx
                        .DbSetStatOdl
                        .FromSqlRaw("EXEC stp_STAT_ODL @IdxODL", IdxODL)
                        .AsNoTracking()
                        .ToListAsync();
                }
            }
            return dbResult;
        }

        /// <summary>
        /// Elenco parametri validi x una data macchina
        /// </summary>
        /// <param name="IdxMacchina"></param>
        /// <returns></returns>
        public List<string> ParametriGetFilt(string IdxMacchina)
        {
            List<string> dbResult = new List<string>();
            using (var dbCtx = new MoonPro_FluxContext(_configuration))
            {
                dbResult = dbCtx
                            .DbSetFluxLog
                            .AsNoTracking()
                            .Where(x => (IdxMacchina == "*" || x.IdxMacchina == IdxMacchina))
                            .Take(1000)
                            .Select(i => i.CodFlux)
                            .Distinct()
                            .OrderBy(x => x)
                            .ToList();
            }
            return dbResult;
        }

        /// <summary>
        /// Stato prod macchina
        /// </summary>
        /// <param name="idxMacchina"></param>
        /// <returns></returns>
        public PzProdModel PezziProdMacchina(string idxMacchina)
        {
            PzProdModel dbResult = new PzProdModel();
            using (var dbCtx = new MoonProContext(_configuration))
            {
                var IdxMacchina = new SqlParameter("@IdxMacchina", idxMacchina);
                dbResult = dbCtx
                            .DbSetPzProd
                            .FromSqlRaw("EXEC stp_PzProd_getByMacchina @IdxMacchina", IdxMacchina)
                            .AsNoTracking()
                            .FirstOrDefault();
            }
            return dbResult;
        }

        /// <summary>
        /// Recupero PODL da chiave
        /// </summary>
        /// <param name="idxPODL"></param>
        /// <returns></returns>
        public async Task<PODLModel> PODL_getByKey(int idxPODL)
        {
            PODLModel dbResult = new PODLModel();
            using (var dbCtx = new MoonProContext(_configuration))
            {
                try
                {
                    dbResult = dbCtx
                                    .DbSetPODL
                                    .AsNoTracking()
                                    .Where(x => x.IdxPromessa == idxPODL)
                                    .Include(a => a.ArticoloNav)
                                    .FirstOrDefault();
                }
                catch (Exception exc)
                {
                    Log.Error($"Eccezione durante PODL_getByKey{Environment.NewLine}{exc}");
                }
            }
            await Task.Delay(1);
            return dbResult;
        }

        /// <summary>
        /// Recupero PODL da IdxOdl
        /// </summary>
        /// <param name="idxPODL"></param>
        /// <returns></returns>
        public PODLModel PODL_getByOdl(int idxODL)
        {
            PODLModel dbResult = new PODLModel();
            using (var dbCtx = new MoonProContext(_configuration))
            {
                try
                {
                    dbResult = dbCtx
                                    .DbSetPODL
                                    .AsNoTracking()
                                    .Where(x => x.IdxOdl == idxODL)
                                    .FirstOrDefault();
                }
                catch (Exception exc)
                {
                    Log.Error($"Eccezione durante PODL_getByOdl{Environment.NewLine}{exc}");
                }
            }
            return dbResult;
        }

        /// <summary>
        /// Avvio setup ODL da PODL
        /// </summary>
        /// <param name="editRec"></param>
        /// <param name="matrOpr"></param>
        /// <param name="tcRich"></param>
        /// <param name="pzPallet"></param>
        /// <param name="note"></param>
        /// <returns></returns>
        public async Task<bool> PODL_startSetup(PODLExpModel editRec, int matrOpr, double tcRich, int pzPallet, string note, DateTime dtEvent)
        {
            bool answ = false;

            PODLModel recPODL = new PODLModel()
            {
                IdxPromessa = editRec.IdxPromessa,
                KeyRichiesta = editRec.KeyRichiesta,
                KeyBCode = editRec.KeyBCode,
                IdxOdl = editRec.IdxOdl,
                CodArticolo = editRec.CodArticolo,
                CodGruppo = editRec.CodGruppo,
                IdxMacchina = editRec.IdxMacchina,
                NumPezzi = editRec.NumPezzi,
                Tcassegnato = editRec.Tcassegnato,
                DueDate = editRec.DueDate,
                Priorita = editRec.Priorita,
                PzPallet = editRec.PzPallet,
                Note = editRec.Note,
                CodCli = editRec.CodCli,
                InsertDate = editRec.InsertDate
            };

            using (var dbCtx = new MoonProContext(_configuration))
            {
                try
                {
                    var currRec = dbCtx
                                    .DbSetPODL
                                    .AsNoTracking()
                                    .Where(x => x.IdxPromessa == recPODL.IdxPromessa)
                                    .FirstOrDefault();

                    if (currRec != null)
                    {
                        // eseguo stored attrezzaggio
                        var IdxPromessa = new SqlParameter("@idxPromessa", recPODL.IdxPromessa);
                        var MatrOpr = new SqlParameter("@MatrOpr", matrOpr);
                        var IdxMacchina = new SqlParameter("@IdxMacchina", recPODL.IdxMacchina);
                        var TCRichAttr = new SqlParameter("@TCRichAttr", tcRich);
                        var PzPallet = new SqlParameter("@PzPallet", pzPallet);
                        var Note = new SqlParameter("@Note", note);
                        var DtEvento = new SqlParameter("@dtEvento", dtEvent);
                        var callResult = await dbCtx
                                        .Database
                                        .ExecuteSqlRawAsync("EXEC stp_ODL_inizioSetupPromessa @idxPromessa, @MatrOpr, @IdxMacchina, @TCRichAttr, @PzPallet, @Note, @dtEvento", IdxPromessa, MatrOpr, IdxMacchina, TCRichAttr, PzPallet, Note, DtEvento);

                        answ = true;
                    }
                }
                catch (Exception exc)
                {
                    Log.Error($"Eccezione durante PODL_doSetup{Environment.NewLine}{exc}");
                }
            }
            await Task.Delay(1);
            return answ;
        }

        /// <summary>
        /// Chiamata salvataggio ricetta su DB
        /// </summary>
        /// <param name="idxPODL"></param>
        /// <param name="recipeName"></param>
        /// <returns></returns>
        public async Task<bool> PODL_updateRecipe(int idxPODL, string recipeName)
        {
            bool answ = false;
            using (var dbCtx = new MoonProContext(_configuration))
            {
                try
                {
                    var currRec = dbCtx
                                    .DbSetPODL
                                    .Where(x => x.IdxPromessa == idxPODL)
                                    .FirstOrDefault();

                    if (currRec != null)
                    {
                        currRec.Recipe = recipeName;
                        dbCtx.Entry(currRec).State = EntityState.Modified;
                        await dbCtx.SaveChangesAsync();
                        answ = true;
                    }
                }
                catch (Exception exc)
                {
                    Log.Error($"Eccezione durante PODL_updateRecipe{Environment.NewLine}{exc}");
                }
            }
            await Task.Delay(1);
            return answ;
        }

        /// <summary>
        /// Eliminazione Record
        /// </summary>
        /// <param name="currRec"></param>
        /// <returns></returns>
        public async Task<bool> PODLDeleteRecord(PODLExpModel currRec)
        {
            PODLModel recPODL = new PODLModel()
            {
                IdxPromessa = currRec.IdxPromessa,
                KeyRichiesta = currRec.KeyRichiesta,
                KeyBCode = currRec.KeyBCode,
                IdxOdl = currRec.IdxOdl,
                CodArticolo = currRec.CodArticolo,
                CodGruppo = currRec.CodGruppo,
                IdxMacchina = currRec.IdxMacchina,
                NumPezzi = currRec.NumPezzi,
                Tcassegnato = currRec.Tcassegnato,
                DueDate = currRec.DueDate,
                Priorita = currRec.Priorita,
                PzPallet = currRec.PzPallet,
                Note = currRec.Note,
                CodCli = currRec.CodCli,
                InsertDate = currRec.InsertDate
            };
            bool fatto = false;
            using (var dbCtx = new MoonProContext(_configuration))
            {
                try
                {
                    var currVal = dbCtx
                                    .DbSetPODL
                                    .Where(x => x.IdxPromessa == recPODL.IdxPromessa)
                                    .FirstOrDefault();
                    dbCtx
                        .DbSetPODL
                        .Remove(currVal);
                    await dbCtx.SaveChangesAsync();
                    fatto = true;
                }
                catch (Exception exc)
                {
                    Log.Error($"Eccezione durante PODLDeleteRecord{Environment.NewLine}{exc}");
                }
            }
            return fatto;
        }

        /// <summary>
        /// Update Record
        /// </summary>
        /// <param name="currRec"></param>
        /// <returns></returns>
        public async Task<bool> PODLUpdateRecord(PODLModel editRec)
        {
            bool fatto = false;
            using (var dbCtx = new MoonProContext(_configuration))
            {
                try
                {
                    var currRec = dbCtx
                                    .DbSetPODL
                                    .Where(x => x.IdxPromessa == editRec.IdxPromessa)
                                    .FirstOrDefault();
                    if (currRec != null)
                    {
                        currRec.CodGruppo = editRec.CodGruppo;
                        currRec.CodArticolo = editRec.CodArticolo;
                        currRec.IdxMacchina = editRec.IdxMacchina;
                        currRec.KeyBCode = editRec.KeyBCode;
                        currRec.KeyRichiesta = editRec.KeyRichiesta;
                        currRec.NumPezzi = editRec.NumPezzi;
                        currRec.Tcassegnato = editRec.Tcassegnato;
                        currRec.Attivabile = editRec.Attivabile;
                        currRec.Note = editRec.Note;
                        dbCtx.Entry(currRec).State = EntityState.Modified;
                    }
                    else
                    {
                        dbCtx
                            .DbSetPODL
                            .Add(editRec);
                    }
                    await dbCtx.SaveChangesAsync();
                    fatto = true;
                }
                catch (Exception exc)
                {
                    Log.Error($"Eccezione durante PODLUpdateRecord{Environment.NewLine}{exc}");
                }
            }
            return fatto;
        }

        /// <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 MoonProContext(_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 Vocabolario (completo)
        /// </summary>
        /// <returns></returns>
        public List<VocabolarioModel> VocabolarioGetAll()
        {
            List<VocabolarioModel> dbResult = new List<VocabolarioModel>();
            using (var dbCtx = new MoonProContext(_configuration))
            {
                dbResult = dbCtx
                    .DbSetVocabolario
                    .AsNoTracking()
                    .OrderBy(x => x.Lemma)
                    .ToList();
            }
            return dbResult;
        }

        #endregion Public Methods

        #region Private Fields

        private static IConfiguration _configuration;

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

        #endregion Private Fields
    }
}