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

using AyCode.Core.Loggers;
using AyCode.Interfaces.Entities;
using FruitBank.Common.Entities;
using FruitBank.Common.Interfaces;
using FruitBank.Common.Loggers;
using FruitBank.Common.Server;
using Mango.Nop.Core.Loggers;
using Mango.Nop.Services;
using Microsoft.AspNetCore.Http;
using Nop.Core;
using Nop.Core.Domain.Catalog;
using Nop.Core.Events;
using Nop.Plugin.Misc.FruitBankPlugin.Controllers;
using Nop.Plugin.Misc.FruitBankPlugin.Domains.DataLayer;
using Nop.Plugin.Misc.FruitBankPlugin.Services;
using Nop.Services.Common;
using Nop.Services.Events;

namespace Nop.Plugin.Misc.FruitBankPlugin.Domains.EventConsumers;

public class FruitBankEventConsumer(IHttpContextAccessor httpContextAccessor, FruitBankDbContext ctx, FruitBankAttributeService fruitBankAttributeService, IStoreContext storeContext, IEnumerable<IAcLogWriterBase> logWriters, IGenericAttributeService genericAttributeService) :
    MgEventConsumer(httpContextAccessor, logWriters), 
    IConsumer<EntityDeletedEvent<Shipping>>,
    IConsumer<EntityInsertedEvent<ShippingItem>>, 
    IConsumer<EntityUpdatedEvent<ShippingItem>>, 
    IConsumer<EntityDeletedEvent<ShippingItem>>,
    IConsumer<EntityInsertedEvent<ShippingDocument>>, 
    IConsumer<EntityUpdatedEvent<ShippingDocument>>, 
    IConsumer<EntityDeletedEvent<ShippingDocument>>, 
    IConsumer<EntityInsertedEvent<ShippingItemPallet>>,
    IConsumer<EntityUpdatedEvent<ShippingItemPallet>>,
    IConsumer<EntityDeletedEvent<ShippingItemPallet>>
{
    public override async Task HandleEventAsync(EntityUpdatedEvent<Product> eventMessage)
    {
        var product = eventMessage.Entity;

        await SaveCustomAttributesAsync(eventMessage.Entity);

        var isMeasurableProduct = await fruitBankAttributeService.IsMeasurableEntityAsync<Product>(product.Id);

        var shippingItems = await ctx.ShippingItems.Table
            .Where(si => si.ProductId == product.Id && !si.IsMeasured && si.IsMeasurable != isMeasurableProduct)
            .ToListAsync();

        foreach (var shippingItem in shippingItems)
            shippingItem.IsMeasurable = isMeasurableProduct;

        await ctx.ShippingItems.UpdateAsync(shippingItems, false);
        await base.HandleEventAsync(eventMessage);
    }

    public async Task HandleEventAsync(EntityInsertedEvent<Product> eventMessage)
    {
        await SaveCustomAttributesAsync(eventMessage.Entity);
    }

    private async Task SaveCustomAttributesAsync(Product product)
    {
        if (product == null)
            return;

        var form = httpContextAccessor.HttpContext?.Request?.Form;
        if (form == null || !form.Any())
            return;

        var isMeasurable = form["IsMeasurable"].ToString().Contains("true");

        // Save IsMeasurable
        if (form.ContainsKey("IsMeasurable"))
        {
            await genericAttributeService.SaveAttributeAsync(product, "IsMeasurable", isMeasurable);
            //Akkor ez kell? - Á.
            //await fruitBankAttributeService.InsertOrUpdateMeasuringAttributeValuesAsync<Product>(product.Id, 0, 0, isMeasurable, false);
        }

        // Save NetWeight
        if (form.ContainsKey("NetWeight"))
        {
            var netWeightStr = form["NetWeight"].ToString();
            if (!string.IsNullOrWhiteSpace(netWeightStr) && decimal.TryParse(netWeightStr, out var netWeight))
            {
                await genericAttributeService.SaveAttributeAsync(product, "NetWeight", netWeight);
                //Akkor ez kell? - Á.
                //await fruitBankAttributeService.InsertOrUpdateMeasuringAttributeValuesAsync<Product>(product.Id, 0, 0, , false);
            }
        }

        // Save IncomingQuantity
        if (form.ContainsKey("IncomingQuantity"))
        {
            var incomingQtyStr = form["IncomingQuantity"].ToString();
            if (!string.IsNullOrWhiteSpace(incomingQtyStr) && int.TryParse(incomingQtyStr, out var incomingQuantity))
            {
                await genericAttributeService.SaveAttributeAsync(product, "IncomingQuantity", incomingQuantity);
            }
        }
    }

    public async Task HandleEventAsync(EntityInsertedEvent<ShippingItemPallet> eventMessage)
    {
        Logger.Info($"HandleEventAsync EntityInsertedEvent<ShippingItemPallet>; id: {eventMessage.Entity.Id}");

        await UpdateShippingItemMeasuringValuesAsync(eventMessage.Entity);
    }

    public async Task HandleEventAsync(EntityUpdatedEvent<ShippingItemPallet> eventMessage)
    {
        Logger.Info($"HandleEventAsync EntityUpdatedEvent<ShippingItemPallet>; id: {eventMessage.Entity.Id}");

        await UpdateShippingItemMeasuringValuesAsync(eventMessage.Entity);
    }

    public async Task HandleEventAsync(EntityDeletedEvent<ShippingItemPallet> eventMessage)
    {
        Logger.Info($"HandleEventAsync EntityDeletedEvent<ShippingItemPallet>; id: {eventMessage.Entity.Id}");

        await UpdateShippingItemMeasuringValuesAsync(eventMessage.Entity);
    }

    private async Task UpdateShippingItemMeasuringValuesAsync(ShippingItemPallet shippingItemPallet)
    {
        var shippingItem = await ctx.ShippingItems.GetByIdAsync(shippingItemPallet.ShippingItemId, false);
        await ctx.UpdateShippingItemAsync(shippingItem);
    }

    public async Task HandleEventAsync(EntityInsertedEvent<ShippingItem> eventMessage)
    {
        Logger.Info($"HandleEventAsync EntityInsertedEvent<ShippingItemPallet>; id: {eventMessage.Entity.Id}");

        await UpdateShippingDocumentIsAllMeasuredAsync(eventMessage.Entity);
    }

    #region Update

    public async Task HandleEventAsync(EntityUpdatedEvent<ShippingItem> eventMessage)
    {
        Logger.Info($"HandleEventAsync EntityUpdatedEvent<ShippingItem>; id: {eventMessage.Entity.Id}");

        var shippingItem = eventMessage.Entity;
        //var isMeasured = shippingItem.IsValidMeasuringValues();

        //if (shippingItem.IsMeasured != isMeasured)
        //{
        //    shippingItem.IsMeasured = isMeasured;
        //    await ctx.ShippingItems.UpdateAsync(shippingItem, false);
        //}

        await UpdateShippingDocumentIsAllMeasuredAsync(shippingItem);
    }

    private async Task UpdateShippingDocumentIsAllMeasuredAsync(ShippingItem shippingItem)
    {
        //TODO: where: && IsMeasurable!!!! - J.
        var isAllShippingItemMeasured = ctx.ShippingItems.GetAll(false).Where(si => si.ShippingDocumentId == shippingItem.ShippingDocumentId).All(si => si.IsMeasured);
        var shippingDocument = await ctx.ShippingDocuments.GetByIdAsync(shippingItem.ShippingDocumentId);

        if (shippingDocument != null && shippingDocument.IsAllMeasured != isAllShippingItemMeasured)
        {
            shippingDocument.IsAllMeasured = isAllShippingItemMeasured;
            await ctx.ShippingDocuments.UpdateAsync(shippingDocument);
        }
    }

    public async Task HandleEventAsync(EntityInsertedEvent<ShippingDocument> eventMessage)
    {
        Logger.Info($"HandleEventAsync EntityInsertedEvent<ShippingDocument>; id: {eventMessage.Entity.Id}");

        await UpdateShippingIsAllMeasuredAsync(eventMessage.Entity);
    }

    public async Task HandleEventAsync(EntityUpdatedEvent<ShippingDocument> eventMessage)
    {
        Logger.Info($"HandleEventAsync EntityUpdatedEvent<ShippingDocument>; id: {eventMessage.Entity.Id}");

        await UpdateShippingIsAllMeasuredAsync(eventMessage.Entity);
    }

    private async Task UpdateShippingIsAllMeasuredAsync(ShippingDocument shippingDocument)
    {
        var isAllShippingDocumentMeasured = ctx.ShippingDocuments.GetAll(false).Where(si => si.ShippingId == shippingDocument.ShippingId).All(si => si.IsAllMeasured);
        var shipping = await ctx.Shippings.GetByIdAsync(shippingDocument.ShippingId);

        if (shipping != null && shipping.IsAllMeasured != isAllShippingDocumentMeasured)
        {
            shipping.IsAllMeasured = isAllShippingDocumentMeasured;
            await ctx.Shippings.UpdateAsync(shipping);
        }
    }

    #endregion Update

    #region Delete

    public async Task HandleEventAsync(EntityDeletedEvent<Shipping> eventMessage)
    {
        Logger.Info($"HandleEventAsync EntityDeletedEvent<Shipping>; id: {eventMessage.Entity.Id}");

        await ctx.ShippingDocuments.DeleteAsync(sd => sd.ShippingId == eventMessage.Entity.Id, true);
    }

    public async Task HandleEventAsync(EntityDeletedEvent<ShippingDocument> eventMessage)
    {
        Logger.Info($"HandleEventAsync EntityDeletedEvent<ShippingDocument>; id: {eventMessage.Entity.Id}");

        await ctx.ShippingItems.DeleteAsync(si => si.ShippingDocumentId == eventMessage.Entity.Id, true);
    }

    public async Task HandleEventAsync(EntityDeletedEvent<ShippingItem> eventMessage)
    {
        Logger.Info($"HandleEventAsync EntityDeletedEvent<ShippingItem>; id: {eventMessage.Entity.Id}");

        await ctx.ShippingItemPallets.DeleteAsync(sp => sp.ShippingItemId == eventMessage.Entity.Id, false);
    }

    #endregion Delete
}