FruitBankHybridApp/FruitBankHybrid.Shared/Services/SignalRs/FruitBankSignalRClient.cs

using AyCode.Core.Helpers;
using AyCode.Core.Loggers;
using AyCode.Services.Server.SignalRs;
using AyCode.Services.SignalRs;
using FruitBank.Common;
using FruitBank.Common.Dtos;
using FruitBank.Common.Entities;
using FruitBank.Common.Interfaces;
using FruitBank.Common.Models;
using FruitBank.Common.SignalRs;
using FruitBankHybrid.Shared.Services.Loggers;
using Mango.Nop.Core.Dtos;
using Mango.Nop.Core.Models;
using Nop.Core.Domain.Customers;

namespace FruitBankHybrid.Shared.Services.SignalRs
{
    public class FruitBankSignalRClient : AcSignalRClientBase, IFruitBankDataControllerClient, ICustomOrderSignalREndpointClient
    {
        public FruitBankSignalRClient( /*IServiceProvider serviceProvider, */ IEnumerable<IAcLogWriterClientBase> logWriters) : base($"{FruitBankConstClient.BaseUrl}/{FruitBankConstClient.DefaultHubName}", new LoggerClient(nameof(FruitBankSignalRClient), logWriters.ToArray()))
        {
            ConstHelper.NameByValue<SignalRTags>(0);
        }

        public Task<List<MeasuringModel>?> GetMeasuringModels()
            => GetAllAsync<List<MeasuringModel>>(SignalRTags.GetMeasuringModels);

        public Task<List<Partner>?> GetPartners()
            => GetAllAsync<List<Partner>>(SignalRTags.GetPartners);

        #region Partner

        public Task<Partner?> GetPartnerById(int id)
            => GetByIdAsync<Partner?>(SignalRTags.GetPartnerById, id);

        public Task<Partner?> UpdatePartner(Partner partner)
            => PostDataAsync(SignalRTags.UpdatePartner, partner);

        #endregion Partner

        #region Shipping

        public Task<List<Shipping>?> GetShippings()
            => GetAllAsync<List<Shipping>>(SignalRTags.GetShippings);

        public Task<List<Shipping>?> GetNotMeasuredShippings()
            => GetAllAsync<List<Shipping>>(SignalRTags.GetNotMeasuredShippings);

        public Task<Shipping?> GetShippingById(int id)
            => GetByIdAsync<Shipping?>(SignalRTags.GetShippingById, id);

        public Task<Shipping?> UpdateShipping(Shipping shipping)
            => PostDataAsync(SignalRTags.UpdateShipping, shipping);

        #endregion Shipping

        #region ShippingItem

        public Task<List<ShippingItem>?> GetShippingItems()
            => GetAllAsync<List<ShippingItem>>(SignalRTags.GetShippingItems);

        public Task<ShippingItem?> GetShippingItemById(int id)
            => GetByIdAsync<ShippingItem?>(SignalRTags.GetShippingItemById, id);

        public Task<ShippingItem?> UpdateShippingItem(ShippingItem shippingItem)
            => PostDataAsync(SignalRTags.UpdateShippingItem, shippingItem);

        public Task<ShippingItem?> UpdateMeasuredShippingItem(ShippingItem shippingItem)
            => PostDataAsync(SignalRTags.UpdateMeasuredShippingItem, shippingItem);

        #endregion ShippingItem

        #region ShippingItemPallet
        public Task<ShippingItemPallet?> AddShippingItemPallet(ShippingItemPallet shippingItemPallet)
            => PostDataAsync(SignalRTags.AddShippingItemPallet, shippingItemPallet);

        public Task<ShippingItemPallet?> UpdateShippingItemPallet(ShippingItemPallet shippingItemPallet)
            => PostDataAsync(SignalRTags.UpdateShippingItemPallet, shippingItemPallet);

        public Task<ShippingItemPallet?> AddOrUpdateMeasuredShippingItemPallet(ShippingItemPallet shippingItemPallet)
            => PostDataAsync(SignalRTags.AddOrUpdateMeasuredShippingItemPallet, shippingItemPallet);

        public Task<ShippingItem?> AddOrUpdateMeasuredShippingItemPallets(List<ShippingItemPallet> shippingItemPallets)
            => PostDataAsync<List<ShippingItemPallet>, ShippingItem>(SignalRTags.AddOrUpdateMeasuredShippingItemPallets, shippingItemPallets);

        #endregion ShippingItemPallet

        #region ShippingDocument

        public Task<List<ShippingDocument>?> GetShippingDocuments()
            => GetAllAsync<List<ShippingDocument>>(SignalRTags.GetShippingDocuments);

        public Task<ShippingDocument?> GetShippingDocumentById(int id)
            => GetByIdAsync<ShippingDocument?>(SignalRTags.GetShippingDocumentById, id);

        public Task<ShippingDocument?> UpdateShippingDocument(ShippingDocument shippingDocument)
            => PostDataAsync(SignalRTags.UpdateShippingDocument, shippingDocument);
        #endregion ShippingDocument

        #region Customer

        public Task<List<CustomerDto>?> GetMeasuringUsers()
            => GetAllAsync<List<CustomerDto>>(SignalRTags.GetMeasuringUsers);
        
        public Task<List<CustomerRole>?> GetCustomerRolesByCustomerId(int customerId)
            => GetAllAsync<List<CustomerRole>>(SignalRTags.GetCustomerRolesByCustomerId, [customerId]);
        #endregion Customer

        #region Product

        public Task<List<ProductDto>?> GetProductDtos()
            => GetAllAsync<List<ProductDto>>(SignalRTags.GetProductDtos);

        //public Task<List<MeasuringProductDto>?> GetAllMeasuringProductDtos()
        //    => GetAllAsync<List<MeasuringProductDto>>(SignalRTags.GetAllMeasuringProductDtos);

        public Task<ProductDto?> GetProductDtoById(int productId)
        => GetByIdAsync<ProductDto?>(SignalRTags.GetMeasuringProductDtoById, productId);

        #endregion Product

        #region Authenticate
        public Task<MgLoginModelResponse?> LoginMeasuringUser(string customerEmail, string customerPassword)
            => LoginMeasuringUser(new MgLoginModelRequest(customerEmail, customerPassword));

        public Task<MgLoginModelResponse?> LoginMeasuringUser(MgLoginModelRequest loginModelRequest)
            => PostDataAsync<MgLoginModelRequest, MgLoginModelResponse>(SignalRTags.AuthenticateUser, loginModelRequest);
        #endregion Authenticate

        #region Orders
        public Task<List<OrderDto>?> GetAllOrderDtos()
            => GetAllAsync<List<OrderDto>>(SignalRTags.GetAllOrderDtos);

        public Task<OrderDto?> GetOrderDtoById(int orderId)
            => GetByIdAsync<OrderDto?>(SignalRTags.GetOrderDtoById, orderId);

        public Task<List<OrderDto>?> GetPendingOrderDtos()
            => GetAllAsync<List<OrderDto>>(SignalRTags.GetPendingOrderDtos);

        public Task<List<OrderDto>?> GetAllOrderDtoByIds(int[] orderIds)
            => GetAllAsync<List<OrderDto>>(SignalRTags.GetAllOrderDtoByIds, [orderIds]);

        public Task<OrderItemPallet?> AddOrUpdateMeasuredOrderItemPallet(OrderItemPallet orderItemPallet)
            => PostDataAsync(SignalRTags.AddOrUpdateMeasuredOrderItemPallet, orderItemPallet);

        public Task<OrderDto?> StartMeasuring(int orderId, int userId)
            => GetByIdAsync<OrderDto>(SignalRTags.StartMeasuring, [orderId, userId]);

        public Task<OrderDto?> SetOrderStatusToComplete(int orderId, int revisorId)
            => GetByIdAsync<OrderDto>(SignalRTags.SetOrderStatusToComplete, [orderId, revisorId]);

        #endregion Orders
    }
}