lux/EgwCoreLib.Lux.Data/Repository/Sales/OfferRowRepository.cs

namespace EgwCoreLib.Lux.Data.Repository.Sales
{
    public class OfferRowRepository : BaseRepository, IOfferRowRepository
    {
        #region Public Constructors

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

        #endregion Public Constructors

        #region Public Methods

        /// <inheritdoc />
        public async Task<bool> AddAsync(OfferRowModel entity)
        {
            await using var dbCtx = await CreateContextAsync(); await using var tx = await dbCtx.Database.BeginTransactionAsync();
            try
            {
                // SE ci fossero righe di indice pari o superiore le deve spostare...
                // 2. Recupero i record successivi da shiftare
                var list2Move = await dbCtx.DbSetOfferRow
                    .Where(x => x.OfferID == entity.OfferID && x.RowNum >= entity.RowNum)
                    .ToListAsync();

                // aggiungo record
                await dbCtx.DbSetOfferRow.AddAsync(entity);
                foreach (var item in list2Move)
                {
                    item.RowNum++;
                    dbCtx.Entry(item).State = EntityState.Modified;
                }

                // Registro modifica su offerta parent...
                var recParent = await dbCtx.DbSetOffer.Where(o => o.OfferID == entity.OfferID).FirstOrDefaultAsync();
                if (recParent != null)
                {
                    recParent.Modified = DateTime.Now;
                }

                bool done = await dbCtx.SaveChangesAsync() > 0;

                if (done)
                    await tx.CommitAsync();

                return done;
            }
            catch
            {
                await tx.RollbackAsync();
                throw;
            }
        }

        /// <inheritdoc />
        public async Task<bool> DeleteAsync(OfferRowModel entity)
        {
            await using var dbCtx = await CreateContextAsync();

            // Wrap in transaction for atomicity (multi-row update + delete)
            await using var tx = await dbCtx.Database.BeginTransactionAsync();
            try
            {
                // 1. Recupero il record da eliminare
                var dbResult = await dbCtx.DbSetOfferRow
                    .FirstOrDefaultAsync(x => x.OfferRowID == entity.OfferRowID);

                if (dbResult == null)
                    return false;

                // 1bis. Registro modifica su offerta parent...
                var recParent = await dbCtx.DbSetOffer.Where(o => o.OfferID == entity.OfferID).FirstOrDefaultAsync();
                if (recParent != null)
                {
                    recParent.Modified = DateTime.Now;
                }

                // 2. Recupero i record successivi da shiftare
                var list2Move = await dbCtx.DbSetOfferRow
                    .Where(x => x.OfferID == entity.OfferID && x.RowNum > dbResult.RowNum)
                    .ToListAsync();

                foreach (var item in list2Move)
                {
                    item.RowNum--;
                    dbCtx.Entry(item).State = EntityState.Modified;
                }

                // 3. Rimuovo il record
                dbCtx.DbSetOfferRow.Remove(dbResult);


                // 4. Salvo tutto
                bool done = await dbCtx.SaveChangesAsync() > 0;

                if (done)
                    await tx.CommitAsync();

                return done;
            }
            catch
            {
                await tx.RollbackAsync();
                throw;
            }
        }

        /// <inheritdoc />
        public async Task<List<ItemModel>> GetBomItemsAsync()
        {
            await using var dbCtx = await CreateContextAsync();
            return await dbCtx.DbSetItem
                .Where(x => x.ItemType == ItemClassType.Bom || x.ItemType == ItemClassType.BomAlt)
                .ToListAsync();
        }

        /// <inheritdoc />
        public async Task<OfferRowModel?> GetByIdAsync(int offerRowId)
        {
            await using var dbCtx = await CreateContextAsync();
            return await dbCtx.DbSetOfferRow
                                .Include(r => r.SellingItemNav)
                                .FirstOrDefaultAsync(x => x.OfferRowID == offerRowId);
        }

        /// <inheritdoc />
        public async Task<List<OfferRowModel>> GetByParentAsync(int offerId)
        {
            await using var dbCtx = await CreateContextAsync();
            return await dbCtx.DbSetOfferRow
                                .Where(x => x.OfferID == offerId)
                                .Include(r => r.SellingItemNav)
                                .AsNoTracking()
                                .ToListAsync();
        }

        /// <inheritdoc />
        public async Task<OfferRowModel?> GetByUidAsync(string offerRowUid)
        {
            await using var dbCtx = await CreateContextAsync();
            return await dbCtx.DbSetOfferRow
                                .Include(r => r.SellingItemNav)
                                .FirstOrDefaultAsync(x => x.OfferRowUID == offerRowUid);
        }

        /// <inheritdoc />
        public async Task<List<ItemGroupModel>> GetItemGroupsAsync()
        {
            await using var dbCtx = await CreateContextAsync();
            return await dbCtx.DbSetItemGroup.ToListAsync();
        }

        /// <inheritdoc />
        public async Task<bool> SaveRowsAsync(List<OfferRowModel> rows)
        {
            // Add validation for null or empty list
            if (rows == null || rows.Count == 0) return false;

            await using var dbCtx = await CreateContextAsync();

            // Wrap in transaction for atomicity (batch update multiple rows)
            await using var tx = await dbCtx.Database.BeginTransactionAsync();
            try
            {
                // Registro modifica su offerta parent...
                var entity = rows.FirstOrDefault();
                if (entity != null)
                {
                    var recParent = await dbCtx.DbSetOffer.Where(o => o.OfferID == entity.OfferID).FirstOrDefaultAsync();
                    if (recParent != null)
                    {
                        recParent.Modified = DateTime.Now;
                    }
                }

                foreach (var row in rows)
                    dbCtx.Entry(row).State = EntityState.Modified;

                bool done = await dbCtx.SaveChangesAsync() > 0;

                if (done)
                    await tx.CommitAsync();

                return done;
            }
            catch
            {
                await tx.RollbackAsync();
                throw;
            }
        }

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

            if (trackedEntity != null)
            {
                // update parent
                var recParent = await dbCtx.DbSetOffer.Where(o => o.OfferID == entity.OfferID).FirstOrDefaultAsync();
                if (recParent != null)
                {
                    recParent.Modified = DateTime.Now;
                }

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

        #endregion Public Methods
    }
}