improvements, fixes...

Nop.Plugin.Misc.AIPlugin/Domains/DataLayer/FruitBankDbContext.cs

@@ -6,15 +6,18 @@ using FruitBank.Common.Dtos;
 using FruitBank.Common.Entities;
 using FruitBank.Common.Interfaces;
 using FruitBank.Common.Models;
+using Mango.Nop.Core.Entities;
 using Mango.Nop.Core.Extensions;
 using Mango.Nop.Core.Loggers;
 using Mango.Nop.Data.Repositories;
+using Microsoft.EntityFrameworkCore;
 using Nop.Core;
 using Nop.Core.Caching;
 using Nop.Core.Domain.Catalog;
 using Nop.Core.Domain.Common;
 using Nop.Core.Domain.Customers;
 using Nop.Core.Domain.Orders;
+using Nop.Core.Domain.Shipping;
 using Nop.Core.Events;
 using Nop.Data;
 using Nop.Plugin.Misc.FruitBankPlugin.Domains.DataLayer.Interfaces;
@@ -65,6 +68,8 @@ public class FruitBankDbContext : MgDbContextBase,
     public IRepository<CustomerAddressMapping> CustomerAddressMappings { get; set; }
 
     public IRepository<GenericAttribute> GenericAttributes { get; set; }
+    public IRepository<StockQuantityHistory> StockQuantityHistories { get; set; }
+    public IRepository<StockQuantityHistoryExt> StockQuantityHistoriesExt { get; set; }
 
     public FruitBankDbContext(INopDataProvider dataProvider, ILockService lockService, FruitBankAttributeService fruitBankAttributeService, IStoreContext storeContext,
         PartnerDbTable partnerDbTable, ShippingDbTable shippingDbTable, ShippingDocumentDbTable shippingDocumentDbTable, ShippingItemDbTable shippingItemDbTable,
@@ -79,6 +84,8 @@ public class FruitBankDbContext : MgDbContextBase,
         IRepository<CustomerAddressMapping> customerAddressMappingRepository,
         IRepository<CustomerRole> customerRoleRepository,
         IRepository<GenericAttribute> genericAttributes,
+        IRepository<StockQuantityHistory> stockQuantityHistories,
+        IRepository<StockQuantityHistoryExt> stockQuantityHistoriesExt,
         IEventPublisher eventPublisher,
         IEnumerable<IAcLogWriterBase> logWriters) : base(productRepository, orderRepository, orderItemRepository, dataProvider, lockService, new Logger<FruitBankDbContext>(logWriters.ToArray()))
     {
@@ -110,6 +117,9 @@ public class FruitBankDbContext : MgDbContextBase,
         CustomerAddressMappings = customerAddressMappingRepository;
 
         GenericAttributes = genericAttributes;
+
+        StockQuantityHistories = stockQuantityHistories;
+        StockQuantityHistoriesExt = stockQuantityHistoriesExt;
     }
 
     public IQueryable<Customer> GetCustomersBySystemRoleName(string systemRoleName)
@@ -282,24 +292,28 @@ public class FruitBankDbContext : MgDbContextBase,
             if (shippingItem.IsMeasured)
             {
                 var quantityInc = productIdChanged ? shippingItem.MeasuredQuantity : shippingItem.MeasuredQuantity - dbShippingItem.MeasuredQuantity;
-                productDto!.StockQuantity += quantityInc;
 
-                if (!await UpdateProductDtoStockQuantityAsync(productDto, true))
+                //productDto!.StockQuantity += quantityInc;
-                    throw new Exception($"UpdateProductStockQuantity() == false; shippingItem! product.Id: {productDto.Id}");
+                //if (!await UpdateProductDtoStockQuantityAsync(productDto, true))
+                //    throw new Exception($"UpdateProductStockQuantity() == false; shippingItem! product.Id: {productDto.Id}");
 
-                var incomingQuantity = productDto.GenericAttributes.GetValueOrNull<int>(nameof(IIncomingQuantity.IncomingQuantity));
+                var incomingQuantity = productDto!.GenericAttributes.GetValueOrNull<int>(nameof(IIncomingQuantity.IncomingQuantity));
                 if (incomingQuantity != null)
                 {
                     await _fruitBankAttributeService.UpdateGenericAttributeAsync<Product, int>
                         (productDto.Id, nameof(IIncomingQuantity.IncomingQuantity), incomingQuantity.Value - quantityInc);
                 }
 
+                var weightToChange = 0d;
                 if (productIsMeasurable)
                 {
-                    await _fruitBankAttributeService.InsertOrUpdateMeasuringAttributeValuesAsync<Product>(productDto.Id,
+                    weightToChange = productIdChanged ? shippingItem.MeasuredNetWeight : shippingItem.MeasuredNetWeight - dbShippingItem.MeasuredNetWeight;
-                        productIdChanged ? shippingItem.MeasuredNetWeight : shippingItem.MeasuredNetWeight - dbShippingItem.MeasuredNetWeight,
+
-                        shippingItem.IsMeasurable, true);
+                    //await _fruitBankAttributeService.InsertOrUpdateMeasuringAttributeValuesAsync<Product>(productDto.Id, weightToChange, shippingItem.IsMeasurable, true);
                 }
+
+                await UpdateStockQuantityAndWeightAsync(productDto, quantityInc, $"Bejövő mérés, shippingItem: #{shippingItem.Id}", weightToChange);
+                //productDto!.StockQuantity += quantityInc;
             }
 
             //if (productIdUnchanged || !dbShippingItem.IsMeasured) return true;
@@ -310,10 +324,10 @@ public class FruitBankDbContext : MgDbContextBase,
             if (productDto != null)
             {
                 productIsMeasurable = productDto.IsMeasurable;
-                productDto.StockQuantity -= dbShippingItem.MeasuredQuantity;
 
-                if (!await UpdateProductDtoStockQuantityAsync(productDto, true))
+                //productDto.StockQuantity -= dbShippingItem.MeasuredQuantity;
-                    throw new Exception($"UpdateProductStockQuantity() == false; dbShippingItem! product.Id: {productDto.Id}");
+                //if (!await UpdateProductDtoStockQuantityAsync(productDto, true))
+                //    throw new Exception($"UpdateProductStockQuantity() == false; dbShippingItem! product.Id: {productDto.Id}");
 
                 var incomingQuantity = productDto.GenericAttributes.GetValueOrNull<int>(nameof(IIncomingQuantity.IncomingQuantity));
                 if (incomingQuantity != null)
@@ -322,10 +336,17 @@ public class FruitBankDbContext : MgDbContextBase,
                         (productDto.Id, nameof(IIncomingQuantity.IncomingQuantity), incomingQuantity.Value + dbShippingItem.MeasuredQuantity);
                 }
 
-                if (!productIsMeasurable) return true;
+                //if (productIsMeasurable)
+                //{
+                //    var measuringValues = new MeasuringAttributeValues(productDto.Id, -dbShippingItem.MeasuredNetWeight, dbShippingItem.IsMeasurable);
+                //    await _fruitBankAttributeService.InsertOrUpdateMeasuringAttributeValuesAsync<Product>(measuringValues, true);
+                //}
 
-                var measuringValues = new MeasuringAttributeValues(productDto.Id, -dbShippingItem.MeasuredNetWeight, dbShippingItem.IsMeasurable);
+                await UpdateStockQuantityAndWeightAsync(productDto, -dbShippingItem.MeasuredQuantity,
-                await _fruitBankAttributeService.InsertOrUpdateMeasuringAttributeValuesAsync<Product>(measuringValues, true);
+                    $"Bejövő mérés, ShippingItem.Id: #{shippingItem.Id}. Product.Id megváltozott, #{productDto.Id}->#{shippingItem.ProductId}!",
+                    -dbShippingItem.MeasuredNetWeight);
+
+                //productDto!.StockQuantity -= dbShippingItem.MeasuredQuantity;
             }
             else Logger.Warning($"product == null; dbShippingItem.ProductId: {dbShippingItem.ProductId}");
             //else //TODO: productIdUnchanged-et lekezelni! - J.
@@ -481,14 +502,18 @@ public class FruitBankDbContext : MgDbContextBase,
 
             if (!orderItemDto.IsMeasurable) continue;
 
-            var prevNetWeightFromGa = orderItemDto.GenericAttributes.GetValueOrDefault<double>(nameof(IMeasuringNetWeight.NetWeight), 0);
+            var prevOrderItemNetWeightFromGa = orderItemDto.GenericAttributes.GetValueOrDefault<double>(nameof(IMeasuringNetWeight.NetWeight), 0);
             //var gaNetWeight = CommonHelper.To<double>(orderItemDto.GenericAttributes.FirstOrDefault(x => x.Key == nameof(IMeasuringNetWeight.NetWeight))?.Value ?? "0");
 
-            await _fruitBankAttributeService.InsertOrUpdateGenericAttributeAsync<OrderItem, double>
+            await _fruitBankAttributeService.InsertOrUpdateGenericAttributeAsync<OrderItem, double>(orderItemDto.Id, nameof(IMeasuringNetWeight.NetWeight), orderItemDto.NetWeight);
-                (orderItemDto.Id, nameof(IMeasuringNetWeight.NetWeight), orderItemDto.NetWeight);
 
-            await _fruitBankAttributeService.InsertOrUpdateMeasuringAttributeValuesAsync<Product>
+            var productWeightToChange = -(orderItemDto.NetWeight - prevOrderItemNetWeightFromGa);
-                (orderItemDto.ProductId, -(orderItemDto.NetWeight - prevNetWeightFromGa), orderItemDto.IsMeasurable, true);
+
+            //await _fruitBankAttributeService.InsertOrUpdateMeasuringAttributeValuesAsync<Product>(orderItemDto.ProductId, productWeightToChange, orderItemDto.IsMeasurable, true);
+
+            await UpdateStockQuantityAndWeightAsync(orderItemDto.ProductId, 0,
+                $"Kimenő mérés, OrderStatus set to complete. Rendelés: #{orderDto.Id}, rendelés tétel: #{orderItemDto.Id}",
+                productWeightToChange);
         }
 
         //await _eventPublisher.PublishAsync(new OrderStatusChangedEvent(order, prevOrderStatus));
@@ -598,32 +623,102 @@ public class FruitBankDbContext : MgDbContextBase,
         return true;
     }
 
-    private async Task<bool> UpdateProductDtoStockQuantityAsync(int productDtoId, bool publishEvent)
+    //private async Task<bool> UpdateProductDtoStockQuantityAsync(int productDtoId, bool publishEvent)
-    {
+    //{
-        var productDto = await ProductDtos.GetByIdAsync(productDtoId, false);
+    //    var productDto = await ProductDtos.GetByIdAsync(productDtoId, false);
-        if (productDto != null) return await UpdateProductDtoStockQuantityAsync(productDto, publishEvent);
+    //    if (productDto != null) return await UpdateProductDtoStockQuantityAsync(productDto, publishEvent);
 
-        Logger.Error($"product == null; id: {productDtoId}");
+    //    Logger.Error($"product == null; id: {productDtoId}");
-        return await Task.FromResult(false);
+    //    return await Task.FromResult(false);
+    //}
+
+    //private async Task<bool> UpdateProductDtoStockQuantityAsync(ProductDto productDto, bool publishEvent)
+    //{
+    //    //TODO: !!!!!!!!!!!!!!!! - J.
+    //    //await _productService.AdjustInventoryAsync(product, quantityInc, string.Empty, "");
+
+    //    await ProductDtos.UpdateAsync(productDto, publishEvent);
+    //    return await Task.FromResult(true);
+
+    //    //var updatedRowsCount = await DataProvider.ExecuteNonQueryAsync($"update product set {nameof(Product.StockQuantity)} = {product.StockQuantity} where {nameof(Product.Id)} = {product.Id}");
+    //    //if (updatedRowsCount == 1) return await Task.FromResult(true);
+
+    //    //Logger.Error($"Product updatedRowsCount != 1; id: {product.Id}");
+    //    //return await Task.FromResult(false);
+    //}
+
+    public async Task UpdateStockQuantityAndWeightAsync(int productId, int quantityToChange, string message, double weightToChange = 0)
+    {
+        if (quantityToChange == 0 && weightToChange == 0) return;
+
+        var product = await Products.GetByIdAsync(productId);
+        await UpdateStockQuantityAndWeightAsync(product, quantityToChange, message, weightToChange);
     }
 
-    private async Task<bool> UpdateProductDtoStockQuantityAsync(ProductDto productDto, bool publishEvent)
+    public async Task UpdateStockQuantityAndWeightAsync(ProductDto productDto, int quantityToChange, string message, double weightToChange = 0)
     {
-        //Itt mi legyen? RollBack? - J.
+        if (quantityToChange == 0 && weightToChange == 0) return;
-        if (productDto.StockQuantity < 0)
-            Logger.Error($"productDto.StockQuantity < 0; Id: {productDto.Id}; StockQuantity: {productDto.StockQuantity}");
 
-        //TODO: !!!!!!!!!!!!!!!! - J.
+        await UpdateStockQuantityAndWeightAsync(productDto.Id, quantityToChange, message, weightToChange);
-        //await _productService.AdjustInventoryAsync(product, quantityInc, string.Empty, "");
+        productDto.StockQuantity += quantityToChange;
 
-        await ProductDtos.UpdateAsync(productDto, publishEvent);
+        if (weightToChange == 0) return;
-        return await Task.FromResult(true);
+        productDto.GenericAttributes = await GenericAttributes.Table.Where(x => x.EntityId == productDto.Id && x.KeyGroup == nameof(Product) && x.StoreId == _storeContext.GetCurrentStore().Id).ToListAsync();
+    }
 
-        //var updatedRowsCount = await DataProvider.ExecuteNonQueryAsync($"update product set {nameof(Product.StockQuantity)} = {product.StockQuantity} where {nameof(Product.Id)} = {product.Id}");
+    public async Task UpdateStockQuantityAndWeightAsync(Product product, int quantityToChange, string message, double weightToChange = 0)
-        //if (updatedRowsCount == 1) return await Task.FromResult(true);
+    {
+        weightToChange = double.Round(weightToChange, 1);
+        if (quantityToChange == 0 && weightToChange == 0) return;
 
-        //Logger.Error($"Product updatedRowsCount != 1; id: {product.Id}");
+        var latStockQuantityHistoryId = 0;
-        //return await Task.FromResult(false);
+
+        if (quantityToChange != 0) await _productService.AdjustInventoryAsync(product, quantityToChange, string.Empty, message);
+        else if (weightToChange != 0)
+        {
+            //Vizsgálja, h a quantityToChange != 0... - J.
+            //await _productService.AddStockQuantityHistoryEntryAsync(product, 0, product.StockQuantity, product.WarehouseId, message);
+
+            var historyEntry = new StockQuantityHistory
+            {
+                ProductId = product.Id,
+                CombinationId = null,
+                WarehouseId = product.WarehouseId > 0 ? (int?)product.WarehouseId : null,
+                QuantityAdjustment = 0,
+                StockQuantity = product.StockQuantity,
+                Message = message,
+                CreatedOnUtc = DateTime.UtcNow
+            };
+
+            await StockQuantityHistories.InsertAsync(historyEntry);
+            latStockQuantityHistoryId = historyEntry.Id;
+        }
+
+        if (weightToChange == 0) return;
+
+        await _fruitBankAttributeService.InsertOrUpdateMeasuringAttributeValuesAsync<Product>(product.Id, weightToChange, true, true);
+
+        if (latStockQuantityHistoryId <= 0)
+        {
+            //A LastOrDefaultAsync elszáll! - J.
+            latStockQuantityHistoryId = await StockQuantityHistories.Table.Where(x => x.ProductId == product.Id).MaxAsync(x => x.Id);
+            if (latStockQuantityHistoryId == 0)
+            {
+                Logger.Error($"UpdateProductDtoStockQuantityAndWeightAsync (latStockQuantityHistory == 0). product.Id: {product.Id}");
+                return;
+            }
+        }
+
+        var stockWeight = double.Round(await _fruitBankAttributeService.GetGenericAttributeValueAsync<Product, double>(product.Id, nameof(IMeasuringNetWeight.NetWeight)), 1);
+
+        var stockQuantityHistoryExt = new StockQuantityHistoryExt
+        {
+            StockQuantityHistoryId = latStockQuantityHistoryId,
+            NetWeightAdjustment = weightToChange,
+            NetWeight = stockWeight,
+        };
+
+        await StockQuantityHistoriesExt.InsertAsync(stockQuantityHistoryExt, false);
     }
 
     public async Task<List<ShippingDocument>> GetShippingDocumentsByShippingIdAsync(int shippingId)

Nop.Plugin.Misc.AIPlugin/Domains/EventConsumers/FruitBankEventConsumer.cs

@@ -117,7 +117,10 @@ public class FruitBankEventConsumer :
             var productDtoNetWeight = productDto?.GenericAttributes.GetValueOrNull<double>(nameof(IMeasuringNetWeight.NetWeight));
 
             if (productDtoNetWeight == null || double.Round(productDtoNetWeight.Value, 1) != netWeight)
-                await _fruitBankAttributeService.InsertOrUpdateGenericAttributeAsync<Product, double>(product.Id, nameof(IMeasuringNetWeight.NetWeight), netWeight);
+            {
+                //await _fruitBankAttributeService.InsertOrUpdateGenericAttributeAsync<Product, double>(product.Id, nameof(IMeasuringNetWeight.NetWeight), netWeight);
+                await _ctx.UpdateStockQuantityAndWeightAsync(productDto, 0, $"Manuális készlet súly változtatás az admin felületen.", netWeight - productDtoNetWeight.GetValueOrDefault(0));
+            }
 
             //Tára
             var tare = double.Round(CommonHelper.To<double>(form[nameof(ITare.Tare)].ToString()), 1);