lux/EgwCoreLib.Lux.Data/Repository/Warehouse/MatReqRepository.cs

namespace EgwCoreLib.Lux.Data.Repository.Warehouse
{
    public class MatReqRepository : BaseRepository, IMatReqRepository
    {

        public MatReqRepository(IDbContextFactory<DataLayerContext> ctxFactory) : base(ctxFactory)
        {
        }

        /// <inheritdoc />
        public async Task<bool> AddAsync(MatReqModel entity)
        {
            await using var dbCtx = await CreateContextAsync();
            await dbCtx.DbSetMaterialReq.AddAsync(entity);
            return await dbCtx.SaveChangesAsync() > 0;
        }
        /// <inheritdoc />
        public async Task<bool> AddManyAsync(List<MatReqModel> listEntity)
        {
            await using var dbCtx = await CreateContextAsync();
            await dbCtx.DbSetMaterialReq.AddRangeAsync(listEntity);
            return await dbCtx.SaveChangesAsync() > 0;
        }


        /// <inheritdoc />
        public async Task<bool> UpsertManyAsync(List<MatReqModel> listEntity)
        {
            await using var dbCtx = await CreateContextAsync();
            //foreach (var entity in listEntity)
            //{
            //    // Recuperiamo l'entità tracciata dal context
            //    var trackedEntity = await dbCtx.DbSetMaterialReq.FirstOrDefaultAsync(x => x.MatReqID == entity.MatReqID);
            //    if (trackedEntity != null)
            //    {
            //        // Aggiorna i valori dell'entità tracciata con quelli della nuova
            //        dbCtx.Entry(trackedEntity).CurrentValues.SetValues(entity);
            //    }
            //    else
            //    {
            //        dbCtx.DbSetMaterialReq.Add(entity);
            //    }
            //}

            // 1. Estrarre tutti gli ID dalla lista di input
            var ids = listEntity.Select(x => x.MatReqID).ToList();

            // 2. Recuperare dal DB solo i record che esistono già (1 sola query)
            var existingEntities = await dbCtx.DbSetMaterialReq
                .Where(x => ids.Contains(x.MatReqID))
                .ToDictionaryAsync(x => x.MatReqID);

            foreach (var entity in listEntity)
            {
                if (existingEntities.TryGetValue(entity.MatReqID, out var trackedEntity))
                {
                    // 3. Aggiornamento: copiamo i valori da 'entity' a quello tracciato
                    dbCtx.Entry(trackedEntity).CurrentValues.SetValues(entity);
                }
                else
                {
                    // 4. Inserimento: nuovo record
                    dbCtx.DbSetMaterialReq.Add(entity);
                }
            }
            return await dbCtx.SaveChangesAsync() > 0;
        }

        /// <inheritdoc />
        public async Task<bool> DeleteAsync(MatReqModel entity)
        {
            await using var dbCtx = await CreateContextAsync();
            dbCtx.DbSetMaterialReq.Remove(entity);
            return await dbCtx.SaveChangesAsync() > 0;
        }

        /// <inheritdoc />
        public async Task<bool> DeleteByOrderRowAsync(int orderRowId, bool force = false)
        {
            await using var dbCtx = await CreateContextAsync();
            // registro eliminazione diretta dei record eliminabilii...
            var list2del = await dbCtx
                                .DbSetMaterialReq
                                .Where(x => x.OrderRowID == orderRowId && (!x.Processed || force))
                                .ExecuteDeleteAsync();

            return await dbCtx.SaveChangesAsync() > 0;
        }

        /// <inheritdoc />
        public async Task<MatReqModel?> GetByIdAsync(int recId)
        {
            await using var dbCtx = await CreateContextAsync();
            return await dbCtx.DbSetMaterialReq
                            .Where(x => x.MatReqID == recId)
                            .Include(s => s.ItemNav)
                            .FirstOrDefaultAsync();
        }

        /// <inheritdoc />
        public async Task<List<MatReqModel>> GetFiltAsync(int? orderID, int? orderRowID, int? itemID, bool? processed)
        {
            await using var dbCtx = await CreateContextAsync();

            var query = dbCtx.DbSetMaterialReq
                                .AsNoTracking()
                                .Include(i => i.ItemNav)
                                .Include(o => o.OrderNav)
                                .Include(s => s.OrderRowNav)
                                //.ThenInclude(o => o.OrderNav)
                                .AsQueryable();

            if (processed != null)
                query = query.Where(s => s.Processed == processed);

            if (itemID != null)
                query = query.Where(s => s.ItemID == itemID);

            if (orderRowID != null)
            {
                query = query.Where(s => s.OrderRowID == orderRowID);
            }
            else
            {
                if (orderID != null)
                    query = query.Where(s => s.OrderRowNav.OrderID == orderID);
            }

            return await query.ToListAsync();
        }


        /// <inheritdoc />
        public async Task<bool> UpdateAsync(MatReqModel entity)
        {
            await using var dbCtx = await CreateContextAsync();
            // Recuperiamo l'entità tracciata dal context
            var trackedEntity = await dbCtx.DbSetMaterialReq.FirstOrDefaultAsync(x => x.MatReqID == entity.MatReqID);

            if (trackedEntity != null)
            {
                // Aggiorna i valori dell'entità tracciata con quelli della nuova
                dbCtx.Entry(trackedEntity).CurrentValues.SetValues(entity);
            }
            else
            {
                dbCtx.DbSetMaterialReq.Update(entity);
            }
            return await dbCtx.SaveChangesAsync() > 0;
        }
    }
}