using Microsoft.Data.SqlClient;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
using MP.Core.DTO;
using MP.Core.Objects;
using MP.Data.DbModels;
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
    {
        #region Public Constructors

        public MpSpecController(IConfiguration configuration)
        {
            _configuration = configuration;
            string connStr = _configuration.GetConnectionString("MP.Data");
            options = new DbContextOptionsBuilder<MoonProContext>()
                                .UseSqlServer(connStr)
                                .Options;
            Log.Info("Avviata classe MpSpecController");
        }

        #endregion Public Constructors

        #region Public Methods

#if false
        /// <summary>
        /// Stacca un nuovo counter x il tipo richiesto
        /// </summary>
        /// <returns></returns>
        public async Task<AnagCountersModel> AnagCountersGetNextAsync(string cntType)
        {
            AnagCountersModel answ = new AnagCountersModel();
            using var dbCtx = new MoonProContext(options);
            bool outTable = true;
            if (outTable)
            {
                var pCntType = new SqlParameter("@CntType", cntType);
                var pLastNum = new SqlParameter
                {
                    ParameterName = "@LastNum",
                    SqlDbType = SqlDbType.Int,
                    Direction = ParameterDirection.Output
                };

                var dbResult = await dbCtx
                                    .DbSetAnagCount
                                    .FromSqlRaw("EXEC dbo.stp_getNextNumb @CntType, @LastNum OUTPUT", pCntType, pLastNum)
                                    .AsNoTracking()
                                    .FirstOrDefaultAsync();
                if (dbResult != null)
                {
                    answ = dbResult;
                }
            }
            else
            {
                // se si volessero impiegare parametri OUTPUT (qui ne mancherebbe 1 nella stored x CntCode...)
                var pCntType = new SqlParameter("@CntType", cntType);
                var pLastNum = new SqlParameter
                {
                    ParameterName = "@LastNum",
                    SqlDbType = SqlDbType.Int,
                    Direction = ParameterDirection.Output
                };
                var pCntCode = new SqlParameter
                {
                    ParameterName = "@CntCode",
                    SqlDbType = SqlDbType.NVarChar,
                    Direction = ParameterDirection.Output
                };
                var dbResult = await dbCtx
                                    .Database
                                    .ExecuteSqlRawAsync("EXEC dbo.stp_getNextNumb @CntType, @LastNum OUTPUT, @CntCode OUTPUT", pCntType, pLastNum, pCntCode);
                if (dbResult != 0)
                {
                    answ.CntType = cntType;
                    answ.CntCode = $"{pCntCode.Value}";
                    int lNum = 0;
                    int.TryParse($"{pLastNum.Value}", out lNum);
                    answ.LastNum = lNum;
                }
            }
            return answ;
        } 

        /// <summary>
        /// Restituisce l'anagrafica EVENTI generalmente disponibile per OGNI macchina
        /// </summary>
        /// <param name="TableName">Nome Table x filtro (std: EvList)</param>
        /// <param name="FieldName">Nome Field x filtro (std: Common)</param>
        /// <returns></returns>
        public async Task<List<vSelEventiBCodeModel>> AnagEventiGeneralAsync(string TableName = "EvList", string FieldName = "Common")
        {
            using var dbCtx = new MoonProContext(options);
            var pTableName = new SqlParameter("@TableName", TableName);
            var pFieldName = new SqlParameter("@FieldName", FieldName);
            var dbResult = await dbCtx
                          .DbSetVSEB
                          .FromSqlRaw("exec dbo.stp_vseb_getGenerallyAvailable @TableName, @FieldName", pTableName, pFieldName)
                          .AsNoTracking()
                          .ToListAsync();
            return dbResult ?? new();
        }


        /// <summary>
        /// Elenco Gruppi tipo Azienda
        /// </summary>
        /// <returns></returns>
        public Task<List<AnagGruppiModel>> AnagGruppiAziendeAsync()
        {
            return AnagGruppiGetTipoAsync("AZIENDA");
        }

        /// <summary>
        /// Delete record AnagraficaGruppi
        /// </summary>
        /// <returns></returns>
        public async Task<bool> AnagGruppiDeleteAsync(AnagGruppiModel updRec)
        {
            using var dbCtx = new MoonProContext(options);
            var dbRec = await dbCtx
                                .DbSetAnagGruppi
                                .AsNoTracking()
                                .Where(x => x.CodGruppo == updRec.CodGruppo)
                                .FirstOrDefaultAsync();
            // se trovato aggiorno descrizione (resto immutato x sicurezza!)
            if (dbRec != null)
            {
                dbCtx.DbSetAnagGruppi.Remove(dbRec);
            }
            var numRes = await dbCtx.SaveChangesAsync();
            return numRes != 0;
        }

        /// <summary>
        /// Elenco Gruppi tipo Fasi
        /// </summary>
        /// <returns></returns>
        public Task<List<AnagGruppiModel>> AnagGruppiFaseAsync()
        {
            return AnagGruppiGetTipoAsync("FASE");
        }


        /// <summary>
        /// Gruppi x tipo modalità Async
        /// </summary>
        /// <param name="tipoGruppo"></param>
        /// <returns></returns>
        public async Task<List<AnagGruppiModel>> AnagGruppiGetTipoAsync(string tipoGruppo)
        {
            using var dbCtx = new MoonProContext(options);
            return await dbCtx
                            .DbSetAnagGruppi
                            .Where(x => x.TipoGruppo == tipoGruppo)
                            .AsNoTracking()
                            .OrderBy(x => x.CodGruppo)
                            .ToListAsync();
        }

        /// <summary>
        /// Elenco Gruppi tipo REPARTO (x associazione Macchine-Operatori) in formato DTO con conteggi del numero record trovati
        /// </summary>
        /// <returns></returns>
        public async Task<List<RepartiDTO>> AnagGruppiRepartoDtoAsync()
        {
            using var dbCtx = new MoonProContext(options);
            // in primis recupero i reparti...
            var listReparti = await AnagGruppiGetTipoAsync("REPARTO");

            // recupero TUTTE le macchine da DbSetGrp2Macc
            var listMacc = await dbCtx
                                .DbSetGrp2Macc
                                .AsNoTracking()
                                .ToListAsync();
            // recupero TUTTI gli operatori da DbSetGrp2Oper
            var listOpr = await dbCtx
                                .DbSetGrp2Oper
                                .AsNoTracking()
                                .ToListAsync();

            return listReparti
                        .Select(x => new RepartiDTO()
                        {
                            CodGruppo = x.CodGruppo,
                            TipoGruppo = x.TipoGruppo,
                            DescrGruppo = x.DescrGruppo,
                            SelEnabled = x.SelEnabled,
                            CountMacc = listMacc.Where(y => y.CodGruppo == x.CodGruppo).Select(x => x.IdxMacchina).Distinct().Count(),
                            CountOpr = listOpr.Where(y => y.CodGruppo == x.CodGruppo).Select(x => x.MatrOpr).Distinct().Count()
                        })
                        .ToList();
        }

        /// <summary>
        /// Upsert record AnagraficaGruppi (solo codice/descrizione)
        /// </summary>
        /// <param name="updRec"></param>
        /// <returns></returns>
        public async Task<bool> AnagGruppiUpsertAsync(AnagGruppiModel updRec)
        {
            using var dbCtx = new MoonProContext(options);
            var dbRec = await dbCtx
                                .DbSetAnagGruppi
                                .AsNoTracking()
                                .Where(x => x.CodGruppo == updRec.CodGruppo)
                                .FirstOrDefaultAsync();
            // se trovato aggiorno descrizione (resto immutato x sicurezza!)
            if (dbRec != null)
            {
                dbRec.DescrGruppo = updRec.DescrGruppo;
                dbCtx.Entry(dbRec).State = EntityState.Modified;
            }
            // altrimenti aggiungo
            else
            {
                await dbCtx.DbSetAnagGruppi.AddAsync(updRec);
            }
            var numRes = await dbCtx.SaveChangesAsync();

            return numRes != 0;
        }
        
#endif

        /// <summary>
        /// Elenco valori ammessi x Stati commessa (es Yacht Baglietto)
        /// </summary>
        /// <returns></returns>
        public Task<List<ListValuesModel>> AnagStatiCommAsync()
        {
            return ListValuesFiltAsync("PODL", "StatoComm");
        }

        /// <summary>
        /// Elenco valori ammessi x Tipo articoli
        /// </summary>
        /// <returns></returns>
        public Task<List<ListValuesModel>> AnagTipoArtLvAsync()
        {
            return ListValuesFiltAsync("AnagArticoli", "Tipo");
        }

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

        /// <summary>
        /// Conteggio num articoli Async
        /// </summary>
        /// <returns></returns>
        public async Task<int> ArticoliCountAsync()
        {
            using var dbCtx = new MoonProContext(options);
            var result = await dbCtx
                            .DbSetArticoli
                            .CountAsync();
            return result;
        }

        /// <summary>
        /// Conteggio articoli data condizione ricerca
        /// </summary>
        /// <param name="tipoArt"></param>
        /// <param name="azienda"></param>
        /// <param name="searchVal"></param>
        /// <returns></returns>
        public async Task<int> ArticoliCountSearchAsync(string tipoArt = "*", string azienda = "*", string searchVal = "")
        {
            using var dbCtx = new MoonProContext(options);
            IQueryable<AnagArticoliModel> query = dbCtx.DbSetArticoli.AsNoTracking();

            // filtro tipo articolo
            if (tipoArt != "*")
            {
                //query = query.Where(x => x.Tipo.ToLower() == tipoArt.ToLower());
                query = query.Where(x => EF.Functions.Like(x.Tipo, tipoArt));
            }
            // filtro azienda
            if (azienda != "*")
            {
                //query = query.Where(x => x.Azienda.ToLower() == azienda.ToLower());
                query = query.Where(x => EF.Functions.Like(x.Azienda, azienda));
            }
            // filtro ricerca
            if (!string.IsNullOrWhiteSpace(searchVal))
            {
                string pattern = $"%{searchVal}%";
                query = query.Where(x =>
                    EF.Functions.Like(x.CodArticolo, pattern) ||
                    EF.Functions.Like(x.DescArticolo, pattern) ||
                    EF.Functions.Like(x.Disegno, pattern));
            }

            return await query
                .OrderBy(x => x.CodArticolo)
                .CountAsync();
        }

        /// <summary>
        /// Elenco tabella Articoli IMPIEGATI (da stored stp_ART_getUsed) Async
        /// </summary>
        /// <returns></returns>
        public async Task<int> ArticoliCountUsedAsync()
        {
            using var dbCtx = new MoonProContext(options);
            var result = await dbCtx
                                  .DbSetCounter
                                  .FromSqlRaw("EXEC stp_ART_CountUsed")
                                  .AsNoTracking()
                                  .ToListAsync();

            return result.FirstOrDefault()?.NumCount ?? 0;
        }

        /// <summary>
        /// Eliminazione Record
        /// </summary>
        /// <param name="currRec"></param>
        /// <returns></returns>
        public async Task<bool> ArticoliDeleteRecordAsync(AnagArticoliModel currRec)
        {
            using var dbCtx = new MoonProContext(options);
            var currVal = dbCtx
                            .DbSetArticoli
                            .Where(x => x.CodArticolo == currRec.CodArticolo)
                            .FirstOrDefault();
            dbCtx
                .DbSetArticoli
                .Remove(currVal);
            return await dbCtx.SaveChangesAsync() > 0;
        }

        /// <summary>
        /// Restitusice elenco articoli dato tipo (es KIT)
        /// </summary>
        /// <param name="tipo"></param>
        /// <param name="azienda"></param>
        /// </summary>
        /// <returns></returns>
        public async Task<List<AnagArticoliModel>> ArticoliGetByTipoAsync(string tipo, string azienda = "*")
        {
            using var dbCtx = new MoonProContext(options);
            return await dbCtx
                            .DbSetArticoli
                            .AsNoTracking()
                            .Where(x => x.Tipo.ToUpper() == tipo.ToUpper() && (azienda == "*" || x.Azienda.ToUpper() == azienda.ToUpper()))
                            .OrderBy(x => x.CodArticolo)
                            .ToListAsync();
        }

#if false
        /// <summary>
        /// Elenco tabella Articoli da filtro
        /// </summary>
        /// <param name="numRecord"></param>
        /// <param name="tipoArt"></param>
        /// <param name="azienda"></param>
        /// <param name="searchVal"></param>
        /// <returns></returns>
        public async Task<List<AnagArticoliModel>> ArticoliGetSearchAsync(int numRecord, string tipoArt = "*", string azienda = "*", string searchVal = "")
        {
            using var dbCtx = new MoonProContext(options);
            IQueryable<AnagArticoliModel> query = dbCtx.DbSetArticoli
                                                        .AsNoTracking();

            // filtro tipo articolo
            if (tipoArt != "*")
            {
                //query = query.Where(x => x.Tipo.ToLower() == tipoArt.ToLower());
                query = query.Where(x => EF.Functions.Like(x.Tipo, tipoArt));
            }
            // filtro azienda
            if (azienda != "*")
            {
                //query = query.Where(x => x.Azienda.ToLower() == azienda.ToLower());
                query = query.Where(x => EF.Functions.Like(x.Azienda, azienda));
            }
            // filtro ricerca
            if (!string.IsNullOrWhiteSpace(searchVal))
            {
                string pattern = $"%{searchVal}%";
                query = query.Where(x =>
                    EF.Functions.Like(x.CodArticolo, pattern) ||
                    EF.Functions.Like(x.DescArticolo, pattern) ||
                    EF.Functions.Like(x.Disegno, pattern));
            }

            return await query
                .OrderBy(x => x.CodArticolo)
                .Take(numRecord)
                .ToListAsync();
        } 
#endif

        /// <summary>
        /// Elenco tabella Articoli NON IMPIEGATI (da stored stp_ART_getUsed) Async
        /// </summary>
        /// <returns></returns>
        public async Task<List<AnagArticoliModel>> ArticoliGetUnusedAsync()
        {
            using var dbCtx = new MoonProContext(options);
            return await dbCtx
                    .DbSetArticoli
                    .FromSqlRaw("EXEC stp_ART_getNotUsed")
                    .AsNoTracking()
                    .ToListAsync();
        }

        /// <summary>
        /// Elenco tabella Articoli IMPIEGATI (da stored stp_ART_getUsed) Async
        /// </summary>
        /// <returns></returns>
        public async Task<List<AnagArticoliModel>> ArticoliGetUsedAsync()
        {
            using var dbCtx = new MoonProContext(options);
            return await dbCtx
                            .DbSetArticoli
                            .FromSqlRaw("EXEC stp_ART_getUsed")
                            .AsNoTracking()
                            .ToListAsync();
        }

        /// <summary>
        /// Elenco Articoli che sono in KIT Child
        /// </summary>
        /// <returns></returns>
        public async Task<List<AnagArticoliModel>> ArticoliInKitAsync()
        {
            List<AnagArticoliModel> dbResult = new List<AnagArticoliModel>();
            using var dbCtx = new MoonProContext(options);
            dbResult = await dbCtx
                            .DbSetArticoli
                            .FromSqlRaw("EXEC stp_TempKIT_getArtChild")
                            .AsNoTracking()
                            .ToListAsync();
            return dbResult;
        }

        /// <summary>
        /// Update Record
        /// </summary>
        /// <param name="currRec"></param>
        /// <returns></returns>
        public async Task<bool> ArticoliUpdateRecord(AnagArticoliModel editRec)
        {
            using var dbCtx = new MoonProContext(options);
            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);
            }
            return await dbCtx.SaveChangesAsync() > 0;
        }

        /// <summary>
        /// Elenco da tabella Config Async
        /// </summary>
        /// <returns></returns>
        public async Task<List<ConfigModel>> ConfigGetAllAsync()
        {
            using var dbCtx = new MoonProContext(options);
            return await dbCtx
                            .DbSetConfig
                            .AsNoTracking()
                            .OrderBy(x => x.Chiave)
                            .ToListAsync() ?? new();
        }

        /// <summary>
        /// Update record config
        /// </summary>
        /// <returns></returns>
        public async Task<bool> ConfigUpdateAsync(ConfigModel updRec)
        {
            bool fatto = false;
            ConfigModel dbResult = new ConfigModel();
            using var dbCtx = new MoonProContext(options);
            dbResult = await dbCtx
                        .DbSetConfig
                        .Where(x => x.Chiave == updRec.Chiave)
                        .FirstOrDefaultAsync();
            if (dbResult != null)
            {
                dbResult.Valore = updRec.Valore;
                fatto = await dbCtx.SaveChangesAsync() > 0;
            }
            return fatto;
        }

        /// <summary>
        /// Eliminazione di un dossier
        /// </summary>
        /// <param name="currRec">record dossier da eliminare</param>
        /// <returns></returns>
        public async Task<bool> DossiersDeleteRecordAsync(DossierModel currRec)
        {
            using var dbCtx = new MoonPro_FluxContext(_configuration);
            var currVal = await dbCtx
                                .DbSetDossiers
                                .Where(x => x.IdxDossier == currRec.IdxDossier)
                                .FirstOrDefaultAsync();
            dbCtx
                .DbSetDossiers
                .Remove(currVal);

            return await dbCtx.SaveChangesAsync() > 0;
        }

        /// <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>
        /// <param name="MaxRec">Num max record recuperati</param>
        /// <returns></returns>
        public async Task<List<DossierModel>> DossiersGetLastFiltAsync(string IdxMacchina, string CodArticolo, DateTime DtStart, DateTime DtEnd, int MaxRec)
        {
            using var dbCtx = new MoonPro_FluxContext(_configuration);
            return await 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)
                            .OrderByDescending(x => x.DtRif)
                            .Take(MaxRec)
                            .ToListAsync();
        }

        /// <summary>
        /// insert di un record Dossier
        /// </summary>
        /// <param name="editRec">record dossier da modificare</param>
        /// <returns></returns>
        public async Task<bool> DossiersInsertAsync(DossierModel newRec)
        {
            using var dbCtx = new MoonPro_FluxContext(_configuration);
            dbCtx
                .DbSetDossiers
                .AddAsync(newRec);
            return await dbCtx.SaveChangesAsync() > 0;
        }

        /// <summary>
        /// Effettua salvataggio snapshot parametri (con stored) + svuota eventuale cache _redisConn
        /// </summary>
        /// <param name="idxMacchina">macchina</param>
        /// <param name="dtMin">Data min x selezione</param>
        /// <param name="dtMax">Data MAX x selezione</param>
        public async Task<bool> DossiersTakeParamsSnapshotLastAsync(string idxMacchina, DateTime dtMin, DateTime dtMax)
        {
            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 = await dbCtx
                .Database
                .ExecuteSqlRawAsync("EXEC stp_FL_TakeSnapshotLast @IdxMacchina,@DtMin,@DtMax", pIdxMacchina, pDtMin, pDtMax);
            return dbResult != 0;
        }

        /// <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> DossiersUpdateValoreAsync(DossierModel editRec)
        {
            using var dbCtx = new MoonPro_FluxContext(_configuration);
            var currRec = await dbCtx
                            .DbSetDossiers
                            .Where(x => x.IdxDossier == editRec.IdxDossier)
                            .FirstOrDefaultAsync();
            if (currRec != null)
            {
                currRec.Valore = editRec.Valore;
                dbCtx.Entry(currRec).State = EntityState.Modified;
            }
            else
            {
                await dbCtx
                    .DbSetDossiers
                    .AddAsync(editRec);
            }
            return await dbCtx.SaveChangesAsync() > 0;
        }

        /// <summary>
        /// Elenco valori link (x home e navMenu laterale)
        /// </summary>
        /// <returns></returns>
        public Task<List<LinkMenuModel>> ElencoLinkAsync()
        {
            return ListLinkFiltAsync("SpecLink");
        }

        /// <summary>
        /// Aggiunta record EventList
        /// </summary>
        /// <param name="newRec"></param>
        /// <returns></returns>
        public async Task<bool> EvListInsertAsync(EventListModel newRec)
        {
            using var dbCtx = new MoonProContext(options);
            var currRec = await dbCtx
                                .DbSetEvList
                                .AddAsync(newRec);

            return await dbCtx.SaveChangesAsync() > 0;
        }

        /// <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>> FluxLogDataReduxAsync(string idxMaccSel, List<string> fluxList, Periodo currPeriodo, Enums.ValSelection valMode, Enums.DataInterval intReq, int maxItem)
        {
            List<StatDedupDTO> procStats = new List<StatDedupDTO>();
            Log.Info($"Inizio FluxLogDataReduxAsync | 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);

            // dbContext condiviso
            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));
            // processo 1:1 ogni flusso
            foreach (var item in fluxList)
            {
                Log.Info($"FluxLogDataReduxAsync | 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;
                // li processo per intervallo richiesto, cercando dati nel periodo eselezionando 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 = await dbCtx
                                            .Database
                                            .ExecuteSqlRawAsync("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 FluxLogDataReduxAsync | 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 async Task<List<FluxLogModel>> FluxLogGetLastFiltAsync(DateTime DtMax, DateTime DtMin, string IdxMacchina, string CodFlux, int MaxRec)
        {
            using var dbCtx = new MoonPro_FluxContext(_configuration);
            return await 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)
                        .ToListAsync() ?? new();
        }

        /// <summary>
        /// Elenco Gruppi
        /// </summary>
        /// <returns></returns>
        public async Task<List<ParetoFluxLogDTO>> FluxLogParetoAsync(string idxMacchina, DateTime dtFrom, DateTime dtTo)
        {
            using var dbCtx = new MoonPro_FluxContext(_configuration);
            return await 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)
                        .ToListAsync() ?? new();
        }

        /// <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> ForceDbMaintAsync(bool doExec, bool doUpdStat, bool doSave, int minPgCnt, int minAvgFrag, int maxAvgFragReb)
        {
            Log.Info($"Inizio ForceDbMaintAsync on MoonProAdminContext");
            // 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);
            Log.Info($"FINE ForceDbMaintAsync on MoonProAdminContext");
            return dbResult != 0;
        }

        /// <summary>
        /// Eliminazione di un record macchina dal gruppo
        /// </summary>
        /// <param name="rec2del"></param>
        /// <returns></returns>
        public async Task<bool> Grp2MaccDeleteAsync(Gruppi2MaccModel rec2del)
        {
            bool answ = false;
            using var dbCtx = new MoonProContext(options);
            var dbRec = await dbCtx
                        .DbSetGrp2Macc
                        .Where(x => x.CodGruppo == rec2del.CodGruppo && x.IdxMacchina == rec2del.IdxMacchina)
                        .FirstOrDefaultAsync();
            if (dbRec != null)
            {
                dbCtx.DbSetGrp2Macc.Remove(dbRec);
                int numDone = await dbCtx.SaveChangesAsync();
                answ = numDone != 0;
            }
            return answ;
        }

        /// <summary>
        /// Insert  di un record macchina
        /// </summary>
        /// <param name="upsRec"></param>
        /// <returns></returns>
        public async Task<bool> Grp2MaccInsertAsync(Gruppi2MaccModel upsRec)
        {
            bool answ = false;
            using var dbCtx = new MoonProContext(options);
            var dbRec = await dbCtx
                        .DbSetGrp2Macc
                        .Where(x => x.CodGruppo == upsRec.CodGruppo && x.IdxMacchina == upsRec.IdxMacchina)
                        .FirstOrDefaultAsync();
            if (dbRec == null)
            {
                await dbCtx.DbSetGrp2Macc.AddAsync(upsRec);
                // salvo
                int numDone = await dbCtx.SaveChangesAsync();
                answ = numDone != 0;
            }
            return answ;
        }

        /// <summary>
        /// Eliminazione di un record operatore dal gruppo
        /// </summary>
        /// <param name="rec2del"></param>
        /// <returns></returns>
        public async Task<bool> Grp2OperDeleteAsync(Gruppi2OperModel rec2del)
        {
            bool answ = false;
            using var dbCtx = new MoonProContext(options);
            var dbRec = await dbCtx
                            .DbSetGrp2Oper
                            .Where(x => x.CodGruppo == rec2del.CodGruppo && x.MatrOpr == rec2del.MatrOpr)
                            .FirstOrDefaultAsync();
            if (dbRec != null)
            {
                dbCtx.DbSetGrp2Oper.Remove(dbRec);
                int numDone = await dbCtx.SaveChangesAsync();
                answ = numDone != 0;
            }
            return answ;
        }

        /// <summary>
        /// Insert di un record operatore
        /// </summary>
        /// <param name="upsRec"></param>
        /// <returns></returns>
        public async Task<bool> Grp2OperInsertAsync(Gruppi2OperModel upsRec)
        {
            bool answ = false;
            using var dbCtx = new MoonProContext(options);
            var dbRec = await dbCtx
                            .DbSetGrp2Oper
                            .Where(x => x.CodGruppo == upsRec.CodGruppo && x.MatrOpr == upsRec.MatrOpr)
                            .FirstOrDefaultAsync();
            if (dbRec == null)
            {
                await dbCtx.DbSetGrp2Oper.AddAsync(upsRec);
                // salvo
                int numDone = await dbCtx.SaveChangesAsync();
                answ = numDone != 0;
            }
            return answ;
        }

        /// <summary>
        /// Elimina record
        /// </summary>
        /// <param name="rec2del"></param>
        public async Task<bool> IstKitDeleteAsync(IstanzeKitModel rec2del)
        {
            using var dbCtx = new MoonProContext(options);
            var actRec = await dbCtx
                                .DbSetInstKit
                                .Where(x => x.KeyKit == rec2del.KeyKit && x.KeyExtOrd == rec2del.KeyExtOrd)
                                .FirstOrDefaultAsync();
            // se ci fosse aggiorno...
            if (actRec != null)
            {
                dbCtx
                    .DbSetInstKit
                    .Remove(actRec);
            }
            return await dbCtx.SaveChangesAsync() > 0;
        }

        /// <summary>
        /// Elenco istanze KIT da ricerca
        /// </summary>
        /// <param name="keyKit"></param>
        /// <param name="keyExtOrd"></param>
        /// <returns></returns>
        public async Task<List<IstanzeKitModel>> IstKitFiltAsync(string keyKit, string keyExtOrd)
        {
            using var dbCtx = new MoonProContext(options);
            return await dbCtx
                           .DbSetInstKit
                           .Where(x => (string.IsNullOrEmpty(keyKit) && string.IsNullOrEmpty(keyExtOrd)) || (x.KeyKit.Contains(keyKit) && !string.IsNullOrEmpty(keyKit)) || (x.KeyExtOrd.Contains(keyExtOrd) && !string.IsNullOrEmpty(keyExtOrd)))
                           .AsNoTracking()
                           .ToListAsync() ?? new();
        }

        /// <summary>
        /// Effettua creazione istanza KIT
        /// </summary>
        /// <param name="CodArtParent">Articolo KIT (fittizio)</param>
        /// <param name="KeyFilt">Chiave x filtro conf su tab WKS</param>
        public async Task<bool> IstKitInsertByWKSAsync(string CodArtParent, string KeyFilt)
        {
            using var dbCtx = new MoonProContext(options);

            var pCodArtParent = new SqlParameter("@CodArtParent", CodArtParent);
            var pKeyFilt = new SqlParameter("@KeyFilt", KeyFilt);

            var dbResult = await dbCtx
                                    .Database
                                    .ExecuteSqlRawAsync("EXEC dbo.stp_IstKit_insertByWKS @CodArtParent,@KeyFilt", pCodArtParent, pKeyFilt);
            return dbResult != 0;
        }

        /// <summary>
        /// Esegue upsert record
        /// </summary>
        /// <param name="editRec"></param>
        public async Task<bool> IstKitUpsertAsync(IstanzeKitModel editRec)
        {
            using var dbCtx = new MoonProContext(options);
            var actRec = await dbCtx
                                .DbSetInstKit
                                .Where(x => x.KeyKit == editRec.KeyKit && x.KeyExtOrd == editRec.KeyExtOrd)
                                .FirstOrDefaultAsync();

            // se ci fosse aggiorno...
            if (actRec == null)
            {
                await dbCtx
                        .DbSetInstKit
                        .AddAsync(editRec);
            }
            else
            {
                actRec.CodArtParent = editRec.CodArtParent;
                actRec.CodArtChild = editRec.CodArtChild;
                actRec.QtyART = editRec.QtyART;
                actRec.QtyKIT = editRec.QtyKIT;
                dbCtx.Entry(actRec).State = EntityState.Modified;
            }
            return await dbCtx.SaveChangesAsync() > 0;
        }

        /// <summary>
        /// Elenco giacenze
        /// </summary>
        /// <param name="IdxOdl">id odl da cercare</param>
        /// <returns></returns>
        public async Task<List<AnagGiacenzeModel>> ListGiacenzeAsync(int IdxOdl)
        {
            List<AnagGiacenzeModel> dbResult = new List<AnagGiacenzeModel>();
            using var dbCtx = new MoonPro_InveContext(_configuration);
            dbResult = await dbCtx
                        .DbGiacenzeData
                        .Where(x => x.IdxOdl == IdxOdl)
                        .AsNoTracking()
                        .ToListAsync();
            return dbResult;
        }

        /// <summary>
        /// Elenco link JQM completo
        /// </summary>
        /// <param name="tipoLink"></param>
        /// <returns></returns>
        public async Task<List<LinkMenuModel>> ListLinkAllAsync()
        {
            using var dbCtx = new MoonProContext(options);
            return await dbCtx
                            .DbSetLinkMenu
                            .AsNoTracking()
                            .OrderBy(x => x.Ordine)
                            .ToListAsync();
        }

        /// <summary>
        /// Elenco link JQM dato filtro tipo, Async
        /// </summary>
        /// <param name="tipoLink"></param>
        /// <returns></returns>
        public async Task<List<LinkMenuModel>> ListLinkFiltAsync(string tipoLink)
        {
            List<LinkMenuModel> dbResult = new List<LinkMenuModel>();
            using var dbCtx = new MoonProContext(options);
            return await dbCtx
                            .DbSetLinkMenu
                            .Where(x => x.TipoLink == tipoLink)
                            .AsNoTracking()
                            .OrderBy(x => x.Ordine)
                            .ToListAsync();
        }

        /// <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 async Task<List<ODLExpModel>> ListODLFiltAsync(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(options);

            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);

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

        /// <summary>
        /// Recupero elenco PODL EXPL filtrati
        /// </summary>
        /// <param name="CodArticolo"></param>
        /// <param name="OnlyAvail">True = aperti (=senza ODL)</param>
        /// <returns></returns>
        public async Task<List<PODLExpModel>> ListPODL_ByCodArtAsync(string CodArticolo, bool OnlyAvail)
        {
            using var dbCtx = new MoonProContext(options);
            var pCodArticolo = new SqlParameter("@CodArticolo", CodArticolo);
            var pOnlyAvail = new SqlParameter("@onlyAvail", OnlyAvail);

            return await dbCtx
                            .DbSetPODLExp
                            .FromSqlRaw("EXEC stp_PODL_getByCodArt @CodArticolo, @onlyAvail", pCodArticolo, pOnlyAvail)
                            .AsNoTracking()
                            .ToListAsync();
        }

        /// <summary>
        /// Elenco PODL in un istanza KIT dall'ID del parent
        /// </summary>
        /// <param name="IdxPodlParent">IDX PODL parent</param>
        /// <returns></returns>
        public async Task<List<PODLExpModel>> ListPODL_ByKitParentAsync(int IdxPodlParent)
        {
            using var dbCtx = new MoonProContext(options);
            var pIdxPodlParent = new SqlParameter("@IdxPodlParent", IdxPodlParent);

            return await dbCtx
                            .DbSetPODLExp
                            .FromSqlRaw("EXEC stp_PODL_getByParentKitIdx @IdxPodlParent", pIdxPodlParent)
                            .AsNoTracking()
                            .ToListAsync();
        }

        /// <summary>
        /// Elenco PODL per composizione KIT 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 async Task<List<PODLExpModel>> ListPODL_KitFiltAsync(bool lanciato, string keyRichPart, string idxMacchina, string codGruppo, DateTime startDate, DateTime endDate)
        {
            using var dbCtx = new MoonProContext(options);
            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);

            return await dbCtx
                            .DbSetPODLExp
                            .FromSqlRaw("EXEC stp_PODL_getByFiltSpecKit @Lanciato, @KeyRich, @CodGruppo, @IdxMacchina, @DtInizio, @DtFine", Lanc, KeyRich, CodGrp, IdxMacc, DateFrom, DateTo)
                            .AsNoTracking()
                            .ToListAsync();
        }

        /// <summary>
        /// Elenco PODL non avviati filtrati x articolo, KeyRich (che contiene stato) - ASYNC
        /// </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 async Task<List<PODLExpModel>> ListPODLFiltAsync(bool lanciato, string keyRichPart, string idxMacchina, string codGruppo, DateTime startDate, DateTime endDate)
        {
            using var dbCtx = new MoonProContext(options);
            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);

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

        /// <summary>
        /// Elenco valori ammessi x tabella/colonna Async
        /// </summary>
        /// <param name="tabName"></param>
        /// <param name="fieldName"></param>
        /// <returns></returns>
        public async Task<List<ListValuesModel>> ListValuesFiltAsync(string tabName, string fieldName)
        {
            using var dbCtx = new MoonProContext(options);
            return await dbCtx
                            .DbSetListValues
                            .Where(x => x.TableName == tabName && x.FieldName == fieldName)
                            .AsNoTracking()
                            .OrderBy(x => x.ordinal)
                            .ToListAsync();
        }

        /// <summary>
        /// Elenco Macchine dato operatore secondo gruppi (macchine/operatore)
        /// </summary>
        /// <param name="MatrOpr"></param>
        /// <returns></returns>
        public async Task<List<MacchineModel>> MacchineByMatrOperAsync(int MatrOpr)
        {
            using var dbCtx = new MoonProContext(options);
            if (MatrOpr == 0)
            {
                return await dbCtx
                            .DbSetMacchine
                            .AsNoTracking()
                            .OrderBy(x => x.IdxMacchina)
                            .ToListAsync();
            }
            else
            {
                return await 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)
                             .ToListAsync();
            }
        }

        /// <summary>
        /// Elenco da tabella Macchine filtro x gruppo
        /// </summary>
        /// <param name="codGruppo"></param>
        /// <returns></returns>
        public async Task<List<MacchineModel>> MacchineGetFiltAsync(string codGruppo)
        {
            using var dbCtx = new MoonProContext(options);
            if (codGruppo == "*")
            {
                return await dbCtx
                            .DbSetMacchine
                            .AsNoTracking()
                            .OrderBy(x => x.IdxMacchina)
                            .ToListAsync();
            }
            else
            {
                return await dbCtx
                            .DbSetGrp2Macc
                            .Where(g => g.CodGruppo == codGruppo)
                            .Join(dbCtx.DbSetMacchine,
                                g => g.IdxMacchina,
                                m => m.IdxMacchina,
                                (g, m) => m
                            )
                            .AsNoTracking()
                            .OrderBy(x => x.IdxMacchina)
                            .ToListAsync();
            }
        }

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

        /// <summary>
        /// Elenco da tabella MappaStatoExplModel
        /// </summary>
        /// <returns></returns>
        public async Task<List<MappaStatoExplModel>> MseGetAllAsync(int maxAge = 2000)
        {
            List<MappaStatoExplModel> dbResult = new List<MappaStatoExplModel>();
            using var dbCtx = new MoonProContext(options);

            var maxAgeSec = new SqlParameter("@maxAgeSec", maxAge);

            dbResult = await dbCtx
                            .DbSetMSE
                            .FromSqlRaw("EXEC stp_MSE_getData @maxAgeSec", maxAgeSec)
                            .AsNoTracking()
                            .ToListAsync();

            return dbResult;
        }

        /// <summary>
        /// Elenco ODL dato batch selezionato
        /// </summary>
        /// <param name="BatchSel">Batch richiesto</param>
        /// <returns></returns>
        public async Task<List<int>> OdlByBatchAsync(string batchSel)
        {
            using var dbCtx = new MoonPro_InveContext(_configuration);
            return await dbCtx
                            .DbGiacenzeData
                            .AsNoTracking()
                            .Where(x => x.IdentRG == batchSel)
                            .Select(x => x.IdxOdl)
                            .ToListAsync();
        }

        /// <summary>
        /// ODL da chiave
        /// </summary>
        /// <returns></returns>
        public async Task<ODLExpModel> OdlByKeyAsync(int IdxOdl)
        {
            using var dbCtx = new MoonProContext(options);
            return await dbCtx
                            .DbSetODLExp
                            .AsNoTracking()
                            .FirstOrDefaultAsync(x => x.IdxOdl == IdxOdl);
        }

        /// <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> ODLCloseAsync(int idxOdl, string idxMacchina, int matrOpr, bool confPezzi, bool confRett, int modoConfProd)
        {
            bool fatto = false;
            if (idxOdl > 0)
            {
                using var dbCtx = new MoonProContext(options);
                DateTime adesso = DateTime.Now;
                // preparo i parametri
                var IdxODL = new SqlParameter("@IdxODL", idxOdl);
                var IdxMacchina = new SqlParameter("@IdxMacchina", idxMacchina);

                // 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 = await dbCtx
                        .Database
                        .ExecuteSqlRawAsync("EXEC stp_ODL_fineProd @IdxODL, @IdxMacchina", IdxODL, IdxMacchina);
                    fatto = dbResult != 0;
                }
                catch (Exception exc)
                {
                    Log.Error($"Eccezione durante ODLCloseAsync{Environment.NewLine}{exc}");
                }
            }
            return fatto;
        }

        /// <summary>
        /// Recupero Odl CORRENTI
        /// </summary>
        /// <returns></returns>
        public async Task<List<ODLModel>> OdlGetCurrentAsync()
        {
            using var dbCtx = new MoonProContext(options);
            return await dbCtx
                                .DbSetODL
                                .Where(x => x.DataInizio != null && x.DataFine == null)
                                .ToListAsync();
        }

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

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

        /// <summary>
        /// Elenco da tabella Operatori filtro x gruppo
        /// </summary>
        /// <param name="codGruppo"></param>
        /// <returns></returns>
        public async Task<List<AnagOperatoriModel>> OperatoriGetFiltAsync(string codGruppo)
        {
            List<AnagOperatoriModel> dbResult = new List<AnagOperatoriModel>();
            using var dbCtx = new MoonProContext(options);
            if (codGruppo == "*")
            {
                dbResult = await dbCtx
                            .DbOperatori
                            .AsNoTracking()
                            .OrderBy(x => x.MatrOpr)
                            .ToListAsync();
            }
            else
            {
                dbResult = await dbCtx
                            .DbSetGrp2Oper
                            .Where(g => g.CodGruppo == codGruppo)
                            .Join(dbCtx.DbOperatori,
                                g => g.MatrOpr,
                                m => m.MatrOpr,
                                (g, m) => m
                            )
                            .AsNoTracking()
                            .OrderBy(x => x.MatrOpr)
                            .ToListAsync();
            }
            return dbResult;
        }

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

        /// <summary>
        /// Recupero PODL da chiave
        /// </summary>
        /// <param name="idxPODL"></param>
        /// <returns></returns>
        public async Task<PODLModel> PODL_getByKeyAsync(int idxPODL)
        {
            using var dbCtx = new MoonProContext(options);
            return await dbCtx
                            .DbSetPODL
                            .AsNoTracking()
                            .Where(x => x.IdxPromessa == idxPODL)
                            .Include(a => a.ArticoloNav)
                            .FirstOrDefaultAsync() ?? new();
        }

        /// <summary>
        /// Recupero PODL da IdxOdl
        /// </summary>
        /// <param name="idxPODL"></param>
        /// <returns></returns>
        public async Task<PODLModel> PODL_getByOdlAsync(int idxODL)
        {
            using var dbCtx = new MoonProContext(options);
            return await dbCtx
                            .DbSetPODL
                            .AsNoTracking()
                            .Where(x => x.IdxOdl == idxODL)
                            .FirstOrDefaultAsync() ?? new();
        }

        /// <summary>
        /// Dizionario associazione ODL/PODL
        /// </summary>
        /// <param name="missingIds"></param>
        /// <returns></returns>
        public async Task<Dictionary<int, int>> PODL_getDictOdlPodlAsync(List<int> missingIds)
        {
            if (missingIds == null || !missingIds.Any())
                return new Dictionary<int, int>();

            using var dbCtx = new MoonProContext(options);
            return await dbCtx
                            .DbSetPODL
                            .AsNoTracking()
                            .Where(x => missingIds.Contains(x.IdxOdl))
                            .ToDictionaryAsync(x => x.IdxOdl, x => x.IdxPromessa);
        }

        /// <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(options);
            var currRec = await dbCtx
                                .DbSetPODL
                                .AsNoTracking()
                                .Where(x => x.IdxPromessa == recPODL.IdxPromessa)
                                .FirstOrDefaultAsync();

            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;
            }
            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(options);
            var currRec = await dbCtx
                                .DbSetPODL
                                .Where(x => x.IdxPromessa == idxPODL)
                                .FirstOrDefaultAsync();

            if (currRec != null)
            {
                currRec.Recipe = recipeName;
                dbCtx.Entry(currRec).State = EntityState.Modified;
                answ = await dbCtx.SaveChangesAsync() > 0;
            }
            return answ;
        }

        /// <summary>
        /// Eliminazione Record
        /// </summary>
        /// <param name="currRec"></param>
        /// <returns></returns>
        public async Task<bool> PODLDeleteRecordAsync(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
            };
            using var dbCtx = new MoonProContext(options);
            var currVal = await dbCtx
                            .DbSetPODL
                            .Where(x => x.IdxPromessa == recPODL.IdxPromessa)
                            .FirstOrDefaultAsync();
            dbCtx
                .DbSetPODL
                .Remove(currVal);
            return await dbCtx.SaveChangesAsync() > 0;
        }

        /// <summary>
        /// Effettua il task di eliminazione PODL KIT + istanze + riattivazione PODL originali disattivate tramite stored
        /// </summary>
        /// <param name="IdxPODL">IdxPODL parent</param>
        public async Task<bool> PodlIstKitDeleteAsync(int IdxPODL)
        {
            using var dbCtx = new MoonProContext(options);
            var pIdxPODL = new SqlParameter("@IdxPODL", IdxPODL);

            var dbResult = await dbCtx
                                    .Database
                                    .ExecuteSqlRawAsync("EXEC dbo.stp_PodlIstKit_delete @IdxPODL", pIdxPODL);
            return dbResult != 0;
        }

        /// <summary>
        /// Update Record
        /// </summary>
        /// <param name="currRec"></param>
        /// <returns></returns>
        public async Task<bool> PODLUpdateRecordAsync(PODLModel editRec)
        {
            using var dbCtx = new MoonProContext(options);
            var currRec = await dbCtx
                            .DbSetPODL
                            .Where(x => x.IdxPromessa == editRec.IdxPromessa)
                            .FirstOrDefaultAsync();
            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
            {
                await dbCtx
                      .DbSetPODL
                      .AddAsync(editRec);
            }
            return await dbCtx.SaveChangesAsync() > 0;
        }

        /// <summary>
        /// Stato macchina (da key)
        /// </summary>
        /// <param name="idxMacchina"></param>
        /// <returns></returns>
        public async Task<StatoMacchineModel> StatoMacchinaAsync(string idxMacchina)
        {
            using var dbCtx = new MoonProContext(options);
            return await dbCtx
                            .DbSetStatoMacc
                            .Where(x => x.IdxMacchina == idxMacchina)
                            .AsNoTracking()
                            .FirstOrDefaultAsync();
        }

        /// <summary>
        /// Elimina record
        /// </summary>
        /// <param name="rec2del"></param>
        public async Task<bool> TemplateKitDeleteAsync(TemplateKitModel rec2del)
        {
            using var dbCtx = new MoonProContext(options);
            var actRec = await dbCtx
                            .DbSetTempKit
                            .Where(x => x.CodArtParent == rec2del.CodArtParent && x.CodArtChild == rec2del.CodArtChild)
                            .FirstOrDefaultAsync();
            // se ci fosse aggiorno...
            if (actRec != null)
            {
                dbCtx
                    .DbSetTempKit
                    .Remove(actRec);
            }
            return await dbCtx.SaveChangesAsync() > 0;
        }

        /// <summary>
        /// Elenco template KIT da ricerca
        /// </summary>
        /// <param name="KitCode"></param>
        /// <param name="codChild"></param>
        /// <returns></returns>
        public async Task<List<TemplateKitModel>> TemplateKitFiltAsync(string KitCode, string codChild)
        {
            List<TemplateKitModel> dbResult = new List<TemplateKitModel>();
            using var dbCtx = new MoonProContext(options);
            dbResult = await dbCtx
                            .DbSetTempKit
                            .Where(x => (string.IsNullOrEmpty(KitCode) && string.IsNullOrEmpty(codChild)) || (x.CodArtParent.Contains(KitCode) && !string.IsNullOrEmpty(KitCode)) || (x.CodArtChild.Contains(codChild) && !string.IsNullOrEmpty(codChild)))
                            .AsNoTracking()
                            .ToListAsync();
            return dbResult;
        }

        /// <summary>
        /// Esegue upsert record
        /// </summary>
        /// <param name="editRec"></param>
        /// <param name="codAzienda"></param>
        public async Task<bool> TemplateKitUpsertAsync(TemplateKitModel editRec, string codAzienda)
        {
            using var dbCtx = new MoonProContext(options);
            // verifico preliminarmente articolo...
            var recArt = dbCtx
                            .DbSetArticoli
                            .FirstOrDefault(x => x.CodArticolo == editRec.CodArtParent);
            // se mancasse...
            if (recArt == null)
            {
                // aggiungo!
                AnagArticoliModel newRecArt = new AnagArticoliModel()
                {
                    CodArticolo = editRec.CodArtParent,
                    Tipo = "KIT",
                    DescArticolo = $"Articolo KIT - {DateTime.Now:yyyy-MM-dd HH:mm:ss}",
                    Disegno = "",
                    Azienda = codAzienda,
                    CurrRev = "",
                    ProdRev = ""
                };
                dbCtx
                    .DbSetArticoli
                    .Add(newRecArt);
            }

            // proseguo col KIT
            var actRec = await dbCtx
                            .DbSetTempKit
                            .Where(x => x.CodArtParent == editRec.CodArtParent && x.CodArtChild == editRec.CodArtChild)
                            .FirstOrDefaultAsync();

            // se NON ci fosse aggiungo...
            if (actRec == null)
            {
                await dbCtx
                    .DbSetTempKit
                    .AddAsync(editRec);
            }
            else
            {
                actRec.Qty = editRec.Qty;
                dbCtx.Entry(actRec).State = EntityState.Modified;
            }
            return await dbCtx.SaveChangesAsync() > 0;
        }

        /// <summary>
        /// Punteggio compatibilità KIT per KeyFilt indicato
        /// </summary>
        /// <param name="KeyFilt"></param>
        /// <param name="MaxResult"></param>
        /// <returns></returns>
        public async Task<List<TksScoreModel>> TksScoreAsync(string KeyFilt, int MaxResult)
        {
            List<TksScoreModel> dbResult = new List<TksScoreModel>();
            if (!string.IsNullOrEmpty(KeyFilt))
            {
                using var dbCtx = new MoonProContext(options);
                var pKeyFilt = new SqlParameter("@KeyFilt", KeyFilt);
                var pMaxRes = new SqlParameter("@maxResult", MaxResult);
                dbResult = await dbCtx
                            .DbSetTksScore
                            .FromSqlRaw("EXEC stp_TKS_Search @KeyFilt, @maxResult", pKeyFilt, pMaxRes)
                            .AsNoTracking()
                            .ToListAsync();
            }
            return dbResult;
        }

        /// <summary>
        /// Elenco Vocabolario di una lingua
        /// </summary>
        /// <returns></returns>
        public Dictionary<string, string> VocabolarioGetLang(string lingua)
        {
            using var dbCtx = new MoonProContext(options);
            var rawList = dbCtx
                    .DbSetVocabolario
                    .AsNoTracking()
                    .Where(x => x.Lingua.ToLower() == lingua.ToLower())
                    .OrderBy(x => x.Lemma)
                    .ToList();
            // Proietto in dizionario
            return rawList
                    .DistinctBy(t => t.Lemma, StringComparer.OrdinalIgnoreCase)
                    .ToDictionary(t => t.Lemma, t => t.Traduzione, StringComparer.OrdinalIgnoreCase);
        }

        /// <summary>
        /// Upsert record Vocabolario
        /// </summary>
        /// <param name="upsRec"></param>
        /// <returns></returns>
        public async Task<bool> VocabolarioUpsertAsync(VocabolarioModel upsRec)
        {
            using var dbCtx = new MoonProContext(options);
            var actRec = await dbCtx
                                .DbSetVocabolario
                                .Where(x => x.Lingua == upsRec.Lingua && x.Lemma == upsRec.Lemma)
                                .FirstOrDefaultAsync();

            // se ci fosse aggiorno...
            if (actRec == null)
            {
                dbCtx
                    .DbSetVocabolario
                    .Add(upsRec);
            }
            else
            {
                actRec.Traduzione = upsRec.Traduzione;
                dbCtx.Entry(actRec).State = EntityState.Modified;
            }
            return await dbCtx.SaveChangesAsync() > 0;
        }

        /// <summary>
        /// Elimina record
        /// </summary>
        /// <param name="rec2del"></param>
        public async Task<bool> WipKitDeleteAsync(WipSetupKitModel rec2del)
        {
            using var dbCtx = new MoonProContext(options);
            var actRec = await dbCtx
                           .DbSetWipKit
                           .Where(x => x.KeyFilt == rec2del.KeyFilt && x.CodOrd == rec2del.CodOrd)
                           .FirstOrDefaultAsync();
            // se ci fosse aggiorno...
            if (actRec != null)
            {
                dbCtx
                    .DbSetWipKit
                    .Remove(actRec);
            }
            return await dbCtx.SaveChangesAsync() > 0;
        }

        /// <summary>
        /// Elimina record + vecchi della data-ora indicata
        /// </summary>
        /// <param name="dateLimit"></param>
        /// <returns></returns>
        public async Task<bool> WipKitDeleteOlderAsync(DateTime dateLimit)
        {
            using var dbCtx = new MoonProContext(options);
            var actRec = await dbCtx
                               .DbSetWipKit
                               .Where(x => x.DataIns < dateLimit)
                               .ToListAsync();
            // se ci fosse aggiorno...
            if (actRec != null)
            {
                dbCtx
                    .DbSetWipKit
                    .RemoveRange(actRec);
            }
            return await dbCtx.SaveChangesAsync() > 0;
        }

        /// <summary>
        /// Elenco record WipSetupKit da KeyFilt
        /// </summary>
        /// <param name="KeyFilt"></param>
        /// <returns></returns>
        public async Task<List<WipSetupKitModel>> WipKitFiltAsync(string KeyFilt)
        {
            List<WipSetupKitModel> dbResult = new List<WipSetupKitModel>();
            // solo se filtro valido...
            if (!string.IsNullOrEmpty(KeyFilt))
            {
                using var dbCtx = new MoonProContext(options);
                dbResult = await dbCtx
                                   .DbSetWipKit
                                   .Where(x => x.KeyFilt.Contains(KeyFilt))
                                   .AsNoTracking()
                                   .ToListAsync();
            }
            return dbResult;
        }

        /// <summary>
        /// Esegue upsert record
        /// </summary>
        /// <param name="editRec"></param>
        public async Task<bool> WipKitUpsertAsync(WipSetupKitModel editRec)
        {
            using var dbCtx = new MoonProContext(options);
            var actRec = await dbCtx
                                .DbSetWipKit
                                .Where(x => x.KeyFilt == editRec.KeyFilt && x.CodOrd == editRec.CodOrd)
                                .FirstOrDefaultAsync();

            // se ci fosse aggiorno...
            if (actRec == null)
            {
                dbCtx
                    .DbSetWipKit
                    .Add(editRec);
            }
            else
            {
                actRec.CodArt = editRec.CodArt;
                actRec.DescArt = editRec.DescArt;
                actRec.Qta = editRec.Qta;
                actRec.DataIns = editRec.DataIns;
                dbCtx.Entry(actRec).State = EntityState.Modified;
            }
            return await dbCtx.SaveChangesAsync() > 0;
        }

        #endregion Public Methods

        #region Private Fields

        private static IConfiguration _configuration;
        private static NLog.Logger Log = LogManager.GetCurrentClassLogger();
        private DbContextOptions<MoonProContext> options;

        #endregion Private Fields
    }
}