Completo repository BuyOrder + aggiungo repository BuyOrderRow

2026-04-14 12:06:29 +02:00
parent ce4a42265e
commit 0ff38c19a4
10 changed files with 273 additions and 87 deletions
@@ -0,0 +1,127 @@
+namespace EgwCoreLib.Lux.Data.Repository.Supplier
+{
+    public class BuyOrderRepository : BaseRepository, IBuyOrderRepository
+    {
+        #region Public Constructors
+
+        public BuyOrderRepository(IDbContextFactory<DataLayerContext> ctxFactory) : base(ctxFactory)
+        {
+        }
+
+        #endregion Public Constructors
+
+        #region Public Methods
+
+        /// <inheritdoc />
+        public async Task<bool> AddAsync(BuyOrderModel entity)
+        {
+            await using var dbCtx = await CreateContextAsync();
+            await dbCtx.DbSetBuyOrder.AddAsync(entity);
+            return await dbCtx.SaveChangesAsync() > 0;
+        }
+
+        /// <inheritdoc />
+        public async Task<bool> DeleteAsync(BuyOrderModel entity)
+        {
+            await using var dbCtx = await CreateContextAsync();
+            dbCtx.DbSetBuyOrder.Remove(entity);
+            return await dbCtx.SaveChangesAsync() > 0;
+        }
+
+        /// <inheritdoc />
+        public async Task<List<BuyOrderModel>> GetAllAsync()
+        {
+            await using var dbCtx = await CreateContextAsync();
+            return await dbCtx.DbSetBuyOrder
+                                .Include(c => c.SupplierNav)
+                                .Include(o => o.BuyOrderRowNav)
+                                .ThenInclude(s => s.ItemNav)
+                                .AsNoTracking()
+                                .ToListAsync();
+        }
+
+        /// <inheritdoc />
+        public async Task<BuyOrderModel?> GetByIdAsync(int recId)
+        {
+            await using var dbCtx = await CreateContextAsync();
+            return await dbCtx.DbSetBuyOrder
+                                .Where(x => x.BuyOrderID == recId)
+                                .Include(c => c.SupplierNav)
+                                .Include(o => o.BuyOrderRowNav)
+                                .ThenInclude(s => s.ItemNav)
+                                .FirstOrDefaultAsync();
+        }
+
+        /// <inheritdoc />
+        public async Task<List<BuyOrderModel>> GetFiltAsync(DateTime inizio, DateTime fine)
+        {
+            await using var dbCtx = await CreateContextAsync();
+            return await dbCtx.DbSetBuyOrder
+                                .Where(x => x.Inserted >= inizio && x.Inserted <= fine)
+                                .Include(c => c.SupplierNav)
+                                .Include(o => o.BuyOrderRowNav)
+                                .ThenInclude(s => s.ItemNav)
+                                .AsNoTracking()
+                                .ToListAsync();
+        }
+
+        /// <inheritdoc />
+        public async Task<List<BuyOrderRowModel>> GetRowsAsync(int recId)
+        {
+            await using var dbCtx = await CreateContextAsync();
+            return await dbCtx.DbSetBuyOrderRow
+                                .Where(x => x.BuyOrderID == recId)
+                                .ToListAsync();
+        }
+
+        /// <inheritdoc />
+        public async Task<bool> SaveRowsAsync(List<BuyOrderRowModel> 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
+            {
+                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(BuyOrderModel entity)
+        {
+            await using var dbCtx = await CreateContextAsync();
+            // Recuperiamo l'entità tracciata dal context
+            var trackedEntity = await dbCtx.DbSetBuyOrder.FirstOrDefaultAsync(x => x.BuyOrderID == entity.BuyOrderID);
+
+            if (trackedEntity != null)
+            {
+                // Aggiorna i valori dell'entità tracciata con quelli della nuova
+                dbCtx.Entry(trackedEntity).CurrentValues.SetValues(entity);
+            }
+            else
+            {
+                dbCtx.DbSetBuyOrder.Update(entity);
+            }
+            return await dbCtx.SaveChangesAsync() > 0;
+        }
+
+        #endregion Public Methods
+    }
+}
@@ -0,0 +1,135 @@
+namespace EgwCoreLib.Lux.Data.Repository.Supplier
+{
+    public class BuyOrderRowrepository : BaseRepository, IBuyOrderRowrepository
+    {
+        #region Public Constructors
+
+        public BuyOrderRowrepository(IDbContextFactory<DataLayerContext> ctxFactory) : base(ctxFactory)
+        {
+        }
+
+        #endregion Public Constructors
+
+        #region Public Methods
+
+        /// <inheritdoc />
+        public async Task<bool> AddAsync(BuyOrderRowModel entity)
+        {
+            await using var dbCtx = await CreateContextAsync();
+            await dbCtx.DbSetBuyOrderRow.AddAsync(entity);
+            return await dbCtx.SaveChangesAsync() > 0;
+        }
+
+        /// <inheritdoc />
+        public async Task<bool> DeleteAsync(BuyOrderRowModel 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.DbSetBuyOrderRow
+                    .FirstOrDefaultAsync(x => x.BuyOrderRowID == entity.BuyOrderRowID);
+
+                if (dbResult == null)
+                    return false;
+
+                // 2. Recupero i record successivi da shiftare
+                var list2Move = await dbCtx.DbSetBuyOrderRow
+                    .Where(x => x.BuyOrderID == entity.BuyOrderID && x.RowNum > dbResult.RowNum)
+                    .ToListAsync();
+
+                foreach (var item in list2Move)
+                {
+                    item.RowNum--;
+                    dbCtx.Entry(item).State = EntityState.Modified;
+                }
+
+                // 3. Rimuovo il record
+                dbCtx.DbSetBuyOrderRow.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<BuyOrderRowModel?> GetByIdAsync(int buyOrderRowId)
+        {
+            await using var dbCtx = await CreateContextAsync();
+            return await dbCtx.DbSetBuyOrderRow
+                                .Include(r => r.ItemNav)
+                                .FirstOrDefaultAsync(x => x.BuyOrderRowID == buyOrderRowId);
+        }
+
+        /// <inheritdoc />
+        public async Task<List<BuyOrderRowModel>> GetByParentAsync(int buyOrderId)
+        {
+            await using var dbCtx = await CreateContextAsync();
+            return await dbCtx.DbSetBuyOrderRow
+                                .Where(x => x.BuyOrderID == buyOrderId)
+                                .Include(r => r.ItemNav)
+                                .AsNoTracking()
+                                .ToListAsync();
+        }
+
+        /// <inheritdoc />
+        public async Task<bool> SaveRowsAsync(List<BuyOrderRowModel> rows)
+        {
+            await using var dbCtx = await CreateContextAsync();
+
+            // Wrap in transaction for atomicity (batch update multiple rows)
+            await using var tx = await dbCtx.Database.BeginTransactionAsync();
+            try
+            {
+                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(BuyOrderRowModel entity)
+        {
+            await using var dbCtx = await CreateContextAsync();
+            // Recuperiamo l'entità tracciata dal context
+            var trackedEntity = await dbCtx.DbSetBuyOrderRow.FirstOrDefaultAsync(x => x.BuyOrderRowID == entity.BuyOrderRowID);
+
+            if (trackedEntity != null)
+            {
+                // Aggiorna i valori dell'entità tracciata con quelli della nuova
+                dbCtx.Entry(trackedEntity).CurrentValues.SetValues(entity);
+            }
+            else
+            {
+                dbCtx.DbSetBuyOrderRow.Update(entity);
+            }
+            return await dbCtx.SaveChangesAsync() > 0;
+        }
+
+        #endregion Public Methods
+    }
+}
@@ -12,13 +12,6 @@
        /// <returns>True se l'inserimento ha successo, false altrimenti.</returns>
        Task<bool> AddAsync(BuyOrderModel entity);

-        /// <summary>
-        /// Esegue il cloning completo di un'Offerta e di tutte le relative righe.
-        /// </summary>
-        /// <param name="rec2clone">L'offerta da clonare.</param>
-        /// <returns>L'ordine creato, o null se l'offerta non esiste.</returns>
-        Task<BuyOrderModel?> CloneOfferAsync(OfferModel rec2clone);
-
        /// <summary>
        /// Elimina un ordine dal database.
        /// </summary>
@@ -32,12 +25,6 @@
        /// <returns>L'elenco di tutti gli ordini con clienti, rivenditori e righe associate.</returns>
        Task<List<BuyOrderModel>> GetAllAsync();

-        /// <summary>
-        /// Recupera l'elenco degli elementi BOM (Bill of Materials) utilizzati negli ordini.
-        /// </summary>
-        /// <returns>L'elenco degli elementi BOM.</returns>
-        Task<List<ItemModel>> GetBomItemsAsync();
-
        /// <summary>
        /// Recupera un ordine per il suo identificatore.
        /// </summary>
@@ -53,12 +40,6 @@
        /// <returns>L'elenco degli ordini nell'intervallo specificato.</returns>
        Task<List<BuyOrderModel>> GetFiltAsync(DateTime inizio, DateTime fine);

-        /// <summary>
-        /// Recupera l'elenco dei gruppi di articoli.
-        /// </summary>
-        /// <returns>L'elenco dei gruppi di articoli.</returns>
-        Task<List<ItemGroupModel>> GetItemGroupsAsync();
-
        /// <summary>
        /// Recupera le righe dell'ordine per un ordine specifico.
        /// </summary>
@@ -19,64 +19,19 @@
        /// <returns>True se l'eliminazione ha successo, false altrimenti.</returns>
        Task<bool> DeleteAsync(BuyOrderRowModel entity);

-        /// <summary>
-        /// Recupera l'elenco degli elementi BOM (Bill of Materials).
-        /// </summary>
-        /// <returns>L'elenco degli elementi BOM.</returns>
-        Task<List<ItemModel>> GetBomItemsAsync();
-
        /// <summary>
        /// Recupera una riga d'ordine per il suo identificatore.
        /// </summary>
-        /// <param name="BuyOrderRowId">L'identificatore della riga d'ordine.</param>
+        /// <param name="buyOrderRowId">L'identificatore della riga d'ordine.</param>
        /// <returns>La riga d'ordine corrispondente, o null se non esiste.</returns>
-        Task<BuyOrderRowModel?> GetByIdAsync(int BuyOrderRowId);
+        Task<BuyOrderRowModel?> GetByIdAsync(int buyOrderRowId);

        /// <summary>
        /// Recupera tutte le righe d'ordine per un ordine specifico.
        /// </summary>
-        /// <param name="orderId">L'identificatore dell'ordine.</param>
+        /// <param name="buyOrderId">L'identificatore dell'ordine.</param>
        /// <returns>L'elenco delle righe d'ordine associate all'ordine.</returns>
-        Task<List<BuyOrderRowModel>> GetByParentAsync(int orderId);
-
-        /// <summary>
-        /// Recupera le righe d'ordine per stato e intervallo di date.
-        /// </summary>
-        /// <param name="reqState">Lo stato richiesto della riga.</param>
-        /// <param name="dtStart">La data di inizio del periodo.</param>
-        /// <param name="dtEnd">La data di fine del periodo.</param>
-        /// <returns>L'elenco delle righe d'ordine con lo stato e le date specificate.</returns>
-        Task<List<BuyOrderRowModel>> GetByStateAsync(OrderStates reqState, DateTime dtStart, DateTime dtEnd);
-
-        /// <summary>
-        /// Recupera le righe d'ordine per stato minimo e intervallo di date.
-        /// </summary>
-        /// <param name="reqState">Lo stato minimo richiesto.</param>
-        /// <param name="dtStart">La data di inizio del periodo.</param>
-        /// <param name="dtEnd">La data di fine del periodo.</param>
-        /// <returns>L'elenco delle righe d'ordine con stato >= a quello specificato.</returns>
-        Task<List<BuyOrderRowModel>> GetByStateMinAsync(OrderStates reqState, DateTime dtStart, DateTime dtEnd);
-
-        /// <summary>
-        /// Recupera una riga d'ordine per il suo UID.
-        /// </summary>
-        /// <param name="BuyOrderRowUid">L'UID della riga d'ordine.</param>
-        /// <returns>La riga d'ordine corrispondente, o null se non esiste.</returns>
-        Task<BuyOrderRowModel?> GetByUidAsync(string BuyOrderRowUid);
-
-        /// <summary>
-        /// Recupera l'elenco dei gruppi di articoli.
-        /// </summary>
-        /// <returns>L'elenco dei gruppi di articoli.</returns>
-        Task<List<ItemGroupModel>> GetItemGroupsAsync();
-
-        /// <summary>
-        /// Aggiorna la stima di produzione per una riga d'ordine.
-        /// </summary>
-        /// <param name="uID">L'UID della riga d'ordine.</param>
-        /// <param name="prodEstim">La nuova stima di produzione.</param>
-        /// <returns>True se l'aggiornamento ha successo, false altrimenti.</returns>
-        Task<bool> SaveProdEstAsync(string uID, string prodEstim);
+        Task<List<BuyOrderRowModel>> GetByParentAsync(int buyOrderId);

        /// <summary>
        /// Aggiorna in batch le righe d'ordine.
@@ -92,11 +47,5 @@
        /// <returns>True se l'aggiornamento ha successo, false altrimenti.</returns>
        Task<bool> UpdateAsync(BuyOrderRowModel entity);

-        /// <summary>
-        /// Convalida un elenco di righe d'ordine e aggiorna lo stato se necessario.
-        /// </summary>
-        /// <param name="list2chk">L'elenco delle righe da convalidare.</param>
-        /// <returns>Il numero di righe elaborate correttamente.</returns>
-        Task<int> ValidateAsync(List<BuyOrderRowModel> list2chk);
    }
 }