FruitBankHybridApp/FruitBankHybrid.Shared/Pages/MeasuringOut.razor.cs

using AyCode.Core.Loggers;
using DevExpress.Blazor;
using FruitBank.Common.Dtos;
using FruitBank.Common.Entities;
using FruitBank.Common.Models;
using FruitBankHybrid.Shared.Models;
using FruitBankHybrid.Shared.Services;
using FruitBankHybrid.Shared.Services.Loggers;
using FruitBankHybrid.Shared.Services.SignalRs;
using Mango.Nop.Core.Loggers;
using Microsoft.AspNetCore.Components;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using FruitBank.Common.Helpers;
using FruitBank.Common.Interfaces;
using AyCode.Core.Extensions;
using Nop.Core.Domain.Orders;

namespace FruitBankHybrid.Shared.Pages
{
    public partial class MeasuringOut : ComponentBase
    {
        [Inject] public required IEnumerable<IAcLogWriterClientBase> LogWriters { get; set; }
        [Inject] public required FruitBankSignalRClient FruitBankSignalRClient { get; set; }
        [Inject] public required LoggedInModel LoggedInModel { get; set; }

        private ILogger _logger = null!;
        private string _errorText;

        private List<OrderDto> SelectedDayOrders { get; set; } = null!;
        private OrderDto? SelectedOrder { get; set; }
        private OrderItemDto? SelectedOrderItem { get; set; }

        private List<MeasuringDateSelectorModel> _measuringDates = null!;

        protected override async Task OnInitializedAsync()
        {
            _logger = new LoggerClient<MeasuringOut>(LogWriters.ToArray());
            _logger.Info("OnInitializedAsync");

            await RefreshOrdersFromDb(DateTime.Now);
            await base.OnInitializedAsync();
        }

        private async Task RefreshOrdersFromDb(DateTime dateTime)
        {
            var orders = await FruitBankSignalRClient.GetPendingOrderDtos() ?? [];

            _measuringDates = orders.Select(order => new MeasuringDateSelectorModel(order.Id, order.DateOfReceiptOrCreated, order.IsMeasured)).ToList();

            SelectedDayOrders = orders.Where(order => MeasuringService.DaysEqual(order.DateOfReceiptOrCreated, dateTime)).ToList();
            SelectedOrder = SelectedDayOrders.FirstOrDefault();

            foreach (var orderItem in SelectedDayOrders.SelectMany(order => order.OrderItemDtos.Where(orderItem => orderItem.OrderItemPallets.Count == 0)))
            {
                orderItem.OrderItemPallets.Add(MeasuringService.CreateNewOrderItemPallet(orderItem, LoggedInModel.CustomerDto));
            }
        }

        private async Task OnMeasuringDateChanged(DateTime selectedDateTime)
            => await RefreshOrdersFromDb(selectedDateTime);

        private void OnCustomDisabledMeasuringDate(CalendarCustomDisabledDateEventArgs args)
            => MeasuringService.OnCustomDisabledDate(args, _measuringDates);

        private string GetMeasuringDateCssClassNames(DateTime date)
            => MeasuringService.GetShippingDateCssClassNames(date, _measuringDates);

        private string GetOrderItemPalletsCssClassNames(string fieldName, OrderItemPallet orderItemPallet)
            => MeasuringService.GetCustomItemPalletsCssClassNames(fieldName, orderItemPallet, orderItemPallet.OrderItemDto!.IsMeasurable);

        private bool IsOrderItemPalletMeasuredAndValid(OrderItemPallet orderItemPallet)
            => MeasuringService.IsCustomItemPalletMeasuredAndValid(orderItemPallet, orderItemPallet.OrderItemDto!.IsMeasurable);

        private void OnSelectedOrderChanged(SelectedDataItemChangedEventArgs<OrderDto> eventArgs)
        {
            //SelectedOrderItem = eventArgs.DataItem?.OrderItemDtos?.FirstOrDefault();
        }

        protected bool BtnSaveEnabled { get; set; }

        protected void OnItemUpdating(string fieldName, object newValue)
        {
            return;
        }

        protected void OnItemUpdating2(string fieldName, object newValue, OrderItemPallet orderItemPallet)
        {
            BtnSaveEnabled = false;
            if (SelectedOrderItem == null) return;

            switch (fieldName)
            {
                case nameof(OrderItemPallet.PalletWeight):
                    orderItemPallet.PalletWeight = (double)newValue;
                    break;

                case nameof(OrderItemPallet.TareWeight):
                    orderItemPallet.TareWeight = (double)newValue;
                    break;

                case nameof(OrderItemPallet.TrayQuantity):
                    orderItemPallet.TrayQuantity = (int)newValue;
                    break;

                case nameof(OrderItemPallet.GrossWeight):
                    orderItemPallet.GrossWeight = (double)newValue;
                    break;
            }

            //MeasuringValuesHelper.SetShippingItemTotalMeasuringValues(SelectedShippingItem);
            //BtnSaveEnabled = SelectedShippingItem.IsValidMeasuringValues() && shippingItemPallet.IsValidMeasuringValues(SelectedShippingItem.IsMeasurable);
        }

        private Task OnOrderItemPalletValueChanged(OrderItemPallet orderItemPallet, OrderItemDto selectedOrderItemDto)
        {
            StateHasChanged();
            return Task.CompletedTask;
        }

        private Task OnOrderItemPalletSaved(OrderItemPallet? orderItemPallet, OrderItemDto selectedOrderItemDto)
        {
            if (orderItemPallet != null)
            {
                selectedOrderItemDto.OrderItemPallets.UpdateCollection(orderItemPallet, false);
                //MeasuringValuesHelper.SetShippingItemTotalMeasuringValues(SelectedShippingItem);
            }
            //else LogErrorAndDisplayText($"Sikertelen volt a raklap adatainak mentése! {orderItemPallet}");

            StateHasChanged();
            return Task.CompletedTask;
        }

        private Task AddNewPalletItemClick(OrderItemDto selectedOrderItemDto)
        {
            if (selectedOrderItemDto.OrderItemPallets[^1].Id > 0)
            {
                selectedOrderItemDto.OrderItemPallets.Add(MeasuringService.CreateNewOrderItemPallet(selectedOrderItemDto, LoggedInModel.CustomerDto));
                StateHasChanged();
            }

            return Task.CompletedTask;
        }

        private Task LastPalletItemDeleteClick(OrderItemDto selectedOrderItemDto)
        {
            if (selectedOrderItemDto.OrderItemPallets.Count <= 1) return Task.CompletedTask;

            var lastPalletItem = selectedOrderItemDto.OrderItemPallets[^1];

            if (lastPalletItem.Id > 0) return Task.CompletedTask;
            selectedOrderItemDto.OrderItemPallets.Remove(lastPalletItem);

            StateHasChanged();
            return Task.CompletedTask;
        }

        private async Task OnMeasuringAuditorClick()
        {
            if (SelectedOrder != null && SelectedOrder.IsMeasured && SelectedOrder.OrderStatus != OrderStatus.Complete)
            {
                var responseOrderDto = await FruitBankSignalRClient.SetOrderStatusToComplete(SelectedOrder.Id);
                if (responseOrderDto != null)
                {
                    SelectedDayOrders.UpdateCollection(responseOrderDto, false);
                    SelectedOrder = responseOrderDto;
                }

                StateHasChanged();

            }
        }
    }
}