Wallet Operations

public sealed class GetPassengerWalletHandler(
    IPassengerWalletRepository passengerWalletRepository,
    ILogger<GetPassengerWalletHandler> logger)
    : IRequestHandler<GetPassengerWalletQuery, GetPassengerWalletResponse>
{
    public async Task<GetPassengerWalletResponse> Handle(
        GetPassengerWalletQuery request, 
        CancellationToken cancellationToken)
    {
        PassengerWallet? wallet = await passengerWalletRepository.GetPassengerWalletAsync(
            request.PassengerId,
            request.Currency,
            cancellationToken);

        if (wallet != null)
        {
            return new GetPassengerWalletResponse
            {
                Currency = wallet.Currency,
                WalletBalance = wallet.WalletBalance,
                HasWallet = true
            };
        }

        return new GetPassengerWalletResponse
        {
            Currency = request.Currency,
            WalletBalance = 0m,
            HasWallet = false
        };
    }
}

public sealed class GetWalletHandler(
    AppDbContext context,
    ITripsUsageClient tripsUsageClient,
    ILogger<GetWalletHandler> logger)
{
    public async Task<Result<GetWalletResponse>> HandleAsync(
        ClaimsPrincipal user,
        CancellationToken cancellationToken = default)
    {
        string driverId = userIdResult.Value;

        Driver driver = await context.Drivers
            .FirstOrDefaultAsync(d => d.Id == driverId && !d.IsDeleted, cancellationToken)
            ?? throw new UserNotFoundException("لم يتم العثور على السائق");

        string? displayCurrencyId = !string.IsNullOrWhiteSpace(driver.DisplayCurrencyId)
            ? driver.DisplayCurrencyId
            : driver.DefaultCurrencyId;

        WalletDataResponse? walletData = await tripsUsageClient.GetDriverWalletAsync(
            driverId, 
            displayCurrency, 
            cancellationToken);

        return Result<GetWalletResponse>.Success(new GetWalletResponse
        {
            Currency = displayCurrency,
            WalletBalance = Math.Round(walletData.WalletBalance, 2),
            TotalEarnings = Math.Round(walletData.TotalEarnings, 2),
            TotalCommission = Math.Round(walletData.TotalCommission, 2),
            NetProfit = Math.Round(walletData.NetProfit, 2)
        });
    }
}

public sealed class WithdrawFromDriverWalletHandler(
    IWalletOperationService walletOps,
    IUsersApiService usersApiService,
    ILogger<WithdrawFromDriverWalletHandler> logger,
    IMessageBus messageBus)
    : IRequestHandler<WithdrawFromDriverWalletCommand, WithdrawFromDriverWalletResponse>
{
    public async Task<WithdrawFromDriverWalletResponse> Handle(
        WithdrawFromDriverWalletCommand request, 
        CancellationToken cancellationToken)
    {
        string currencyCode = await CurrencyResolver.ResolveCodeAsync(
            request.Currency, usersApiService, cancellationToken);

        var result = await walletOps.AdminWithdrawFromDriverAsync(
            new AdminWithdrawFromDriverRequest(
                request.DriverId,
                currencyCode,
                request.Amount,
                request.AdminId,
                request.TransferReference,
                request.Notes),
            cancellationToken);

        if (result.Success)
        {
            await messageBus.PublishAsync(new WalletWithdrawnNotification(
                request.DriverId,
                request.Amount,
                currencyCode,
                result.BalanceAfter,
                request.TransferReference));
        }

        return new WithdrawFromDriverWalletResponse
        {
            Success = result.Success,
            Message = result.Success
                ? $"تم سحب {request.Amount} {currencyCode} بنجاح"
                : result.ErrorMessage ?? "فشل في سحب المبلغ",
            NewBalance = result.BalanceAfter
        };
    }
}