[AC-1800] PayPal IPN Refactor (#3619)

* Add more logging to PayPal IPN webhook

* Add PayPalIPNClient tests

* Add PayPalControllerTests

---------

Co-authored-by: aelinton <95626935+aelinton@users.noreply.github.com>

src/Billing/Controllers/PayPalController.cs

@@ -1,5 +1,6 @@
 using System.Text;
-using Bit.Billing.Utilities;
+using Bit.Billing.Models;
+using Bit.Billing.Services;
 using Bit.Core.Entities;
 using Bit.Core.Enums;
 using Bit.Core.Repositories;
@@ -15,220 +16,256 @@ namespace Bit.Billing.Controllers;
 public class PayPalController : Controller
 {
     private readonly BillingSettings _billingSettings;
-    private readonly PayPalIpnClient _paypalIpnClient;
-    private readonly ITransactionRepository _transactionRepository;
-    private readonly IOrganizationRepository _organizationRepository;
-    private readonly IUserRepository _userRepository;
-    private readonly IMailService _mailService;
-    private readonly IPaymentService _paymentService;
     private readonly ILogger<PayPalController> _logger;
+    private readonly IMailService _mailService;
+    private readonly IOrganizationRepository _organizationRepository;
+    private readonly IPaymentService _paymentService;
+    private readonly IPayPalIPNClient _payPalIPNClient;
+    private readonly ITransactionRepository _transactionRepository;
+    private readonly IUserRepository _userRepository;
 
     public PayPalController(
         IOptions<BillingSettings> billingSettings,
-        PayPalIpnClient paypalIpnClient,
-        ITransactionRepository transactionRepository,
-        IOrganizationRepository organizationRepository,
-        IUserRepository userRepository,
+        ILogger<PayPalController> logger,
         IMailService mailService,
+        IOrganizationRepository organizationRepository,
         IPaymentService paymentService,
-        ILogger<PayPalController> logger)
+        IPayPalIPNClient payPalIPNClient,
+        ITransactionRepository transactionRepository,
+        IUserRepository userRepository)
     {
         _billingSettings = billingSettings?.Value;
-        _paypalIpnClient = paypalIpnClient;
-        _transactionRepository = transactionRepository;
-        _organizationRepository = organizationRepository;
-        _userRepository = userRepository;
-        _mailService = mailService;
-        _paymentService = paymentService;
         _logger = logger;
+        _mailService = mailService;
+        _organizationRepository = organizationRepository;
+        _paymentService = paymentService;
+        _payPalIPNClient = payPalIPNClient;
+        _transactionRepository = transactionRepository;
+        _userRepository = userRepository;
     }
 
     [HttpPost("ipn")]
     public async Task<IActionResult> PostIpn()
     {
-        _logger.LogDebug("PayPal webhook has been hit.");
-        if (HttpContext?.Request?.Query == null)
+        var key = HttpContext.Request.Query.ContainsKey("key")
+            ? HttpContext.Request.Query["key"].ToString()
+            : null;
+
+        if (string.IsNullOrEmpty(key))
         {
-            return new BadRequestResult();
+            _logger.LogError("PayPal IPN: Key is missing");
+            return BadRequest();
         }
 
-        var key = HttpContext.Request.Query.ContainsKey("key") ?
-            HttpContext.Request.Query["key"].ToString() : null;
         if (!CoreHelpers.FixedTimeEquals(key, _billingSettings.PayPal.WebhookKey))
         {
-            _logger.LogWarning("PayPal webhook key is incorrect or does not exist.");
-            return new BadRequestResult();
+            _logger.LogError("PayPal IPN: Key is incorrect");
+            return BadRequest();
         }
 
-        string body = null;
-        using (var reader = new StreamReader(HttpContext.Request.Body, Encoding.UTF8))
+        using var streamReader = new StreamReader(HttpContext.Request.Body, Encoding.UTF8);
+
+        var requestContent = await streamReader.ReadToEndAsync();
+
+        if (string.IsNullOrEmpty(requestContent))
         {
-            body = await reader.ReadToEndAsync();
+            _logger.LogError("PayPal IPN: Request body is null or empty");
+            return BadRequest();
         }
 
-        if (string.IsNullOrWhiteSpace(body))
+        var transactionModel = new PayPalIPNTransactionModel(requestContent);
+
+        var entityId = transactionModel.UserId ?? transactionModel.OrganizationId;
+
+        if (!entityId.HasValue)
         {
-            return new BadRequestResult();
+            _logger.LogError("PayPal IPN ({Id}): 'custom' did not contain a User ID or Organization ID", transactionModel.TransactionId);
+            return BadRequest();
         }
 
-        var verified = await _paypalIpnClient.VerifyIpnAsync(body);
+        var verified = await _payPalIPNClient.VerifyIPN(entityId.Value, requestContent);
+
         if (!verified)
         {
-            _logger.LogWarning("Unverified IPN received.");
-            return new BadRequestResult();
+            _logger.LogError("PayPal IPN ({Id}): Verification failed", transactionModel.TransactionId);
+            return BadRequest();
         }
 
-        var ipnTransaction = new PayPalIpnClient.IpnTransaction(body);
-        if (ipnTransaction.TxnType != "web_accept" && ipnTransaction.TxnType != "merch_pmt" &&
-            ipnTransaction.PaymentStatus != "Refunded")
+        if (transactionModel.TransactionType != "web_accept" &&
+            transactionModel.TransactionType != "merch_pmt" &&
+            transactionModel.PaymentStatus != "Refunded")
         {
-            // Only processing billing agreement payments, buy now button payments, and refunds for now.
-            return new OkResult();
+            _logger.LogWarning("PayPal IPN ({Id}): Transaction type ({Type}) not supported for payments",
+                transactionModel.TransactionId,
+                transactionModel.TransactionType);
+
+            return Ok();
         }
 
-        if (ipnTransaction.ReceiverId != _billingSettings.PayPal.BusinessId)
+        if (transactionModel.ReceiverId != _billingSettings.PayPal.BusinessId)
         {
-            _logger.LogWarning("Receiver was not proper business id. " + ipnTransaction.ReceiverId);
-            return new BadRequestResult();
+            _logger.LogWarning(
+                "PayPal IPN ({Id}): Receiver ID ({ReceiverId}) does not match Bitwarden business ID ({BusinessId})",
+                transactionModel.TransactionId,
+                transactionModel.ReceiverId,
+                _billingSettings.PayPal.BusinessId);
+
+            return Ok();
         }
 
-        if (ipnTransaction.PaymentStatus == "Refunded" && ipnTransaction.ParentTxnId == null)
+        if (transactionModel.PaymentStatus == "Refunded" && string.IsNullOrEmpty(transactionModel.ParentTransactionId))
         {
-            // Refunds require parent transaction
-            return new OkResult();
+            _logger.LogWarning("PayPal IPN ({Id}): Parent transaction ID is required for refund", transactionModel.TransactionId);
+            return Ok();
         }
 
-        if (ipnTransaction.PaymentType == "echeck" && ipnTransaction.PaymentStatus != "Refunded")
+        if (transactionModel.PaymentType == "echeck" && transactionModel.PaymentStatus != "Refunded")
         {
-            // Not accepting eChecks, unless it is a refund
-            _logger.LogWarning("Got an eCheck payment. " + ipnTransaction.TxnId);
-            return new OkResult();
+            _logger.LogWarning("PayPal IPN ({Id}): Transaction was an eCheck payment", transactionModel.TransactionId);
+            return Ok();
         }
 
-        if (ipnTransaction.McCurrency != "USD")
+        if (transactionModel.MerchantCurrency != "USD")
         {
-            // Only process USD payments
-            _logger.LogWarning("Received a payment not in USD. " + ipnTransaction.TxnId);
-            return new OkResult();
+            _logger.LogWarning("PayPal IPN ({Id}): Transaction was not in USD ({Currency})",
+                transactionModel.TransactionId,
+                transactionModel.MerchantCurrency);
+
+            return Ok();
         }
 
-        var ids = ipnTransaction.GetIdsFromCustom();
-        if (!ids.Item1.HasValue && !ids.Item2.HasValue)
+        switch (transactionModel.PaymentStatus)
         {
-            return new OkResult();
-        }
-
-        if (ipnTransaction.PaymentStatus == "Completed")
-        {
-            var transaction = await _transactionRepository.GetByGatewayIdAsync(
-                GatewayType.PayPal, ipnTransaction.TxnId);
-            if (transaction != null)
-            {
-                _logger.LogWarning("Already processed this completed transaction. #" + ipnTransaction.TxnId);
-                return new OkResult();
-            }
-
-            var isAccountCredit = ipnTransaction.IsAccountCredit();
-            try
-            {
-                var tx = new Transaction
+            case "Completed":
                 {
-                    Amount = ipnTransaction.McGross,
-                    CreationDate = ipnTransaction.PaymentDate,
-                    OrganizationId = ids.Item1,
-                    UserId = ids.Item2,
-                    Type = isAccountCredit ? TransactionType.Credit : TransactionType.Charge,
-                    Gateway = GatewayType.PayPal,
-                    GatewayId = ipnTransaction.TxnId,
-                    PaymentMethodType = PaymentMethodType.PayPal,
-                    Details = ipnTransaction.TxnId
-                };
-                await _transactionRepository.CreateAsync(tx);
+                    var existingTransaction = await _transactionRepository.GetByGatewayIdAsync(
+                        GatewayType.PayPal,
+                        transactionModel.TransactionId);
 
-                if (isAccountCredit)
-                {
-                    string billingEmail = null;
-                    if (tx.OrganizationId.HasValue)
+                    if (existingTransaction != null)
                     {
-                        var org = await _organizationRepository.GetByIdAsync(tx.OrganizationId.Value);
-                        if (org != null)
+                        _logger.LogWarning("PayPal IPN ({Id}): Already processed this completed transaction", transactionModel.TransactionId);
+                        return Ok();
+                    }
+
+                    try
+                    {
+                        var transaction = new Transaction
                         {
-                            billingEmail = org.BillingEmailAddress();
-                            if (await _paymentService.CreditAccountAsync(org, tx.Amount))
-                            {
-                                await _organizationRepository.ReplaceAsync(org);
-                            }
+                            Amount = transactionModel.MerchantGross,
+                            CreationDate = transactionModel.PaymentDate,
+                            OrganizationId = transactionModel.OrganizationId,
+                            UserId = transactionModel.UserId,
+                            Type = transactionModel.IsAccountCredit ? TransactionType.Credit : TransactionType.Charge,
+                            Gateway = GatewayType.PayPal,
+                            GatewayId = transactionModel.TransactionId,
+                            PaymentMethodType = PaymentMethodType.PayPal,
+                            Details = transactionModel.TransactionId
+                        };
+
+                        await _transactionRepository.CreateAsync(transaction);
+
+                        if (transactionModel.IsAccountCredit)
+                        {
+                            await ApplyCreditAsync(transaction);
                         }
                     }
-                    else
+                    // Catch foreign key violations because user/org could have been deleted.
+                    catch (SqlException sqlException) when (sqlException.Number == 547)
                     {
-                        var user = await _userRepository.GetByIdAsync(tx.UserId.Value);
-                        if (user != null)
+                        _logger.LogError("PayPal IPN ({Id}): SQL Exception | {Message}", transactionModel.TransactionId, sqlException.Message);
+                    }
+
+                    break;
+                }
+            case "Refunded" or "Reversed":
+                {
+                    var existingTransaction = await _transactionRepository.GetByGatewayIdAsync(
+                        GatewayType.PayPal,
+                        transactionModel.TransactionId);
+
+                    if (existingTransaction != null)
+                    {
+                        _logger.LogWarning("PayPal IPN ({Id}): Already processed this refunded transaction", transactionModel.TransactionId);
+                        return Ok();
+                    }
+
+                    var parentTransaction = await _transactionRepository.GetByGatewayIdAsync(
+                        GatewayType.PayPal,
+                        transactionModel.ParentTransactionId);
+
+                    if (parentTransaction == null)
+                    {
+                        _logger.LogError("PayPal IPN ({Id}): Could not find parent transaction", transactionModel.TransactionId);
+                        return BadRequest();
+                    }
+
+                    var refundAmount = Math.Abs(transactionModel.MerchantGross);
+
+                    var remainingAmount = parentTransaction.Amount - parentTransaction.RefundedAmount.GetValueOrDefault();
+
+                    if (refundAmount > 0 && !parentTransaction.Refunded.GetValueOrDefault() && remainingAmount >= refundAmount)
+                    {
+                        parentTransaction.RefundedAmount = parentTransaction.RefundedAmount.GetValueOrDefault() + refundAmount;
+
+                        if (parentTransaction.RefundedAmount == parentTransaction.Amount)
                         {
-                            billingEmail = user.BillingEmailAddress();
-                            if (await _paymentService.CreditAccountAsync(user, tx.Amount))
-                            {
-                                await _userRepository.ReplaceAsync(user);
-                            }
+                            parentTransaction.Refunded = true;
                         }
+
+                        await _transactionRepository.ReplaceAsync(parentTransaction);
+
+                        await _transactionRepository.CreateAsync(new Transaction
+                        {
+                            Amount = refundAmount,
+                            CreationDate = transactionModel.PaymentDate,
+                            OrganizationId = transactionModel.OrganizationId,
+                            UserId = transactionModel.UserId,
+                            Type = TransactionType.Refund,
+                            Gateway = GatewayType.PayPal,
+                            GatewayId = transactionModel.TransactionId,
+                            PaymentMethodType = PaymentMethodType.PayPal,
+                            Details = transactionModel.TransactionId
+                        });
                     }
 
-                    if (!string.IsNullOrWhiteSpace(billingEmail))
-                    {
-                        await _mailService.SendAddedCreditAsync(billingEmail, tx.Amount);
-                    }
+                    break;
                 }
-            }
-            // Catch foreign key violations because user/org could have been deleted.
-            catch (SqlException e) when (e.Number == 547) { }
         }
-        else if (ipnTransaction.PaymentStatus == "Refunded" || ipnTransaction.PaymentStatus == "Reversed")
+
+        return Ok();
+    }
+
+    private async Task ApplyCreditAsync(Transaction transaction)
+    {
+        string billingEmail = null;
+
+        if (transaction.OrganizationId.HasValue)
         {
-            var refundTransaction = await _transactionRepository.GetByGatewayIdAsync(
-                GatewayType.PayPal, ipnTransaction.TxnId);
-            if (refundTransaction != null)
+            var organization = await _organizationRepository.GetByIdAsync(transaction.OrganizationId.Value);
+
+            if (await _paymentService.CreditAccountAsync(organization, transaction.Amount))
             {
-                _logger.LogWarning("Already processed this refunded transaction. #" + ipnTransaction.TxnId);
-                return new OkResult();
+                await _organizationRepository.ReplaceAsync(organization);
+
+                billingEmail = organization.BillingEmailAddress();
             }
+        }
+        else if (transaction.UserId.HasValue)
+        {
+            var user = await _userRepository.GetByIdAsync(transaction.UserId.Value);
 
-            var parentTransaction = await _transactionRepository.GetByGatewayIdAsync(
-                GatewayType.PayPal, ipnTransaction.ParentTxnId);
-            if (parentTransaction == null)
+            if (await _paymentService.CreditAccountAsync(user, transaction.Amount))
             {
-                _logger.LogWarning("Parent transaction was not found. " + ipnTransaction.TxnId);
-                return new BadRequestResult();
-            }
+                await _userRepository.ReplaceAsync(user);
 
-            var refundAmount = System.Math.Abs(ipnTransaction.McGross);
-            var remainingAmount = parentTransaction.Amount -
-                parentTransaction.RefundedAmount.GetValueOrDefault();
-            if (refundAmount > 0 && !parentTransaction.Refunded.GetValueOrDefault() &&
-                remainingAmount >= refundAmount)
-            {
-                parentTransaction.RefundedAmount =
-                    parentTransaction.RefundedAmount.GetValueOrDefault() + refundAmount;
-                if (parentTransaction.RefundedAmount == parentTransaction.Amount)
-                {
-                    parentTransaction.Refunded = true;
-                }
-
-                await _transactionRepository.ReplaceAsync(parentTransaction);
-                await _transactionRepository.CreateAsync(new Transaction
-                {
-                    Amount = refundAmount,
-                    CreationDate = ipnTransaction.PaymentDate,
-                    OrganizationId = ids.Item1,
-                    UserId = ids.Item2,
-                    Type = TransactionType.Refund,
-                    Gateway = GatewayType.PayPal,
-                    GatewayId = ipnTransaction.TxnId,
-                    PaymentMethodType = PaymentMethodType.PayPal,
-                    Details = ipnTransaction.TxnId
-                });
+                billingEmail = user.BillingEmailAddress();
             }
         }
 
-        return new OkResult();
+        if (!string.IsNullOrEmpty(billingEmail))
+        {
+            await _mailService.SendAddedCreditAsync(billingEmail, transaction.Amount);
+        }
     }
 }

src/Billing/Models/PayPalIPNTransactionModel.cs

@@ -0,0 +1,110 @@
+using System.Globalization;
+using System.Runtime.InteropServices;
+using System.Web;
+
+namespace Bit.Billing.Models;
+
+public class PayPalIPNTransactionModel
+{
+    public string TransactionId { get; }
+    public string TransactionType { get; }
+    public string ParentTransactionId { get; }
+    public string PaymentStatus { get; }
+    public string PaymentType { get; }
+    public decimal MerchantGross { get; }
+    public string MerchantCurrency { get; }
+    public string ReceiverId { get; }
+    public DateTime PaymentDate { get; }
+    public Guid? UserId { get; }
+    public Guid? OrganizationId { get; }
+    public bool IsAccountCredit { get; }
+
+    public PayPalIPNTransactionModel(string formData)
+    {
+        var queryString = HttpUtility.ParseQueryString(formData);
+
+        var data = queryString
+            .AllKeys
+            .ToDictionary(key => key, key => queryString[key]);
+
+        TransactionId = Extract(data, "txn_id");
+        TransactionType = Extract(data, "txn_type");
+        ParentTransactionId = Extract(data, "parent_txn_id");
+        PaymentStatus = Extract(data, "payment_status");
+        PaymentType = Extract(data, "payment_type");
+
+        var merchantGross = Extract(data, "mc_gross");
+        if (!string.IsNullOrEmpty(merchantGross))
+        {
+            MerchantGross = decimal.Parse(merchantGross);
+        }
+
+        MerchantCurrency = Extract(data, "mc_currency");
+        ReceiverId = Extract(data, "receiver_id");
+
+        var paymentDate = Extract(data, "payment_date");
+        PaymentDate = ToUTCDateTime(paymentDate);
+
+        var custom = Extract(data, "custom");
+
+        if (string.IsNullOrEmpty(custom))
+        {
+            return;
+        }
+
+        var metadata = custom.Split(',')
+            .Where(field => !string.IsNullOrEmpty(field) && field.Contains(':'))
+            .Select(field => field.Split(':'))
+            .ToDictionary(parts => parts[0], parts => parts[1]);
+
+        if (metadata.TryGetValue("user_id", out var userIdStr) &&
+            Guid.TryParse(userIdStr, out var userId))
+        {
+            UserId = userId;
+        }
+
+        if (metadata.TryGetValue("organization_id", out var organizationIdStr) &&
+            Guid.TryParse(organizationIdStr, out var organizationId))
+        {
+            OrganizationId = organizationId;
+        }
+
+        IsAccountCredit = custom.Contains("account_credit:1");
+    }
+
+    private static string Extract(IReadOnlyDictionary<string, string> data, string key)
+    {
+        var success = data.TryGetValue(key, out var value);
+        return success ? value : null;
+    }
+
+    private static DateTime ToUTCDateTime(string input)
+    {
+        if (string.IsNullOrEmpty(input))
+        {
+            return default;
+        }
+
+        var success = DateTime.TryParseExact(input,
+            new[]
+            {
+                "HH:mm:ss dd MMM yyyy PDT",
+                "HH:mm:ss dd MMM yyyy PST",
+                "HH:mm:ss dd MMM, yyyy PST",
+                "HH:mm:ss dd MMM, yyyy PDT",
+                "HH:mm:ss MMM dd, yyyy PST",
+                "HH:mm:ss MMM dd, yyyy PDT"
+            }, CultureInfo.InvariantCulture, DateTimeStyles.None, out var dateTime);
+
+        if (!success)
+        {
+            return default;
+        }
+
+        var pacificTime = RuntimeInformation.IsOSPlatform(OSPlatform.Windows)
+            ? TimeZoneInfo.FindSystemTimeZoneById("Pacific Standard Time")
+            : TimeZoneInfo.FindSystemTimeZoneById("America/Los_Angeles");
+
+        return TimeZoneInfo.ConvertTimeToUtc(dateTime, pacificTime);
+    }
+}

src/Billing/Services/IPayPalIPNClient.cs

@@ -0,0 +1,6 @@
+namespace Bit.Billing.Services;
+
+public interface IPayPalIPNClient
+{
+    Task<bool> VerifyIPN(Guid entityId, string formData);
+}

src/Billing/Services/Implementations/PayPalIPNClient.cs

@@ -0,0 +1,86 @@
+using System.Text;
+using Microsoft.Extensions.Options;
+
+namespace Bit.Billing.Services.Implementations;
+
+public class PayPalIPNClient : IPayPalIPNClient
+{
+    private readonly HttpClient _httpClient;
+    private readonly Uri _ipnEndpoint;
+    private readonly ILogger<PayPalIPNClient> _logger;
+
+    public PayPalIPNClient(
+        IOptions<BillingSettings> billingSettings,
+        HttpClient httpClient,
+        ILogger<PayPalIPNClient> logger)
+    {
+        _httpClient = httpClient;
+        _ipnEndpoint = new Uri(billingSettings.Value.PayPal.Production
+            ? "https://www.paypal.com/cgi-bin/webscr"
+            : "https://www.sandbox.paypal.com/cgi-bin/webscr");
+        _logger = logger;
+    }
+
+    public async Task<bool> VerifyIPN(Guid entityId, string formData)
+    {
+        LogInfo(entityId, $"Verifying IPN against {_ipnEndpoint}");
+
+        if (string.IsNullOrEmpty(formData))
+        {
+            throw new ArgumentNullException(nameof(formData));
+        }
+
+        var requestMessage = new HttpRequestMessage { Method = HttpMethod.Post, RequestUri = _ipnEndpoint };
+
+        var requestContent = string.Concat("cmd=_notify-validate&", formData);
+
+        LogInfo(entityId, $"Request Content: {requestContent}");
+
+        requestMessage.Content = new StringContent(requestContent, Encoding.UTF8, "application/x-www-form-urlencoded");
+
+        var response = await _httpClient.SendAsync(requestMessage);
+
+        var responseContent = await response.Content.ReadAsStringAsync();
+
+        if (response.IsSuccessStatusCode)
+        {
+            return responseContent switch
+            {
+                "VERIFIED" => Verified(),
+                "INVALID" => Invalid(),
+                _ => Unhandled(responseContent)
+            };
+        }
+
+        LogError(entityId, $"Unsuccessful Response | Status Code: {response.StatusCode} | Content: {responseContent}");
+
+        return false;
+
+        bool Verified()
+        {
+            LogInfo(entityId, "Verified");
+            return true;
+        }
+
+        bool Invalid()
+        {
+            LogError(entityId, "Verification Invalid");
+            return false;
+        }
+
+        bool Unhandled(string content)
+        {
+            LogWarning(entityId, $"Unhandled Response Content: {content}");
+            return false;
+        }
+    }
+
+    private void LogInfo(Guid entityId, string message)
+        => _logger.LogInformation("Verify PayPal IPN ({RequestId}) | {Message}", entityId, message);
+
+    private void LogWarning(Guid entityId, string message)
+        => _logger.LogWarning("Verify PayPal IPN ({RequestId}) | {Message}", entityId, message);
+
+    private void LogError(Guid entityId, string message)
+        => _logger.LogError("Verify PayPal IPN ({RequestId}) | {Message}", entityId, message);
+}

src/Billing/Startup.cs

@@ -43,12 +43,12 @@ public class Startup
         // Repositories
         services.AddDatabaseRepositories(globalSettings);
 
-        // PayPal Client
-        services.AddSingleton<Utilities.PayPalIpnClient>();
-
         // BitPay Client
         services.AddSingleton<BitPayClient>();
 
+        // PayPal IPN Client
+        services.AddHttpClient<IPayPalIPNClient, PayPalIPNClient>();
+
         // Context
         services.AddScoped<ICurrentContext, CurrentContext>();
 

src/Billing/Utilities/PayPalIpnClient.cs

@@ -1,176 +0,0 @@
-using System.Globalization;
-using System.Runtime.InteropServices;
-using System.Text;
-using System.Web;
-using Microsoft.Extensions.Options;
-
-namespace Bit.Billing.Utilities;
-
-public class PayPalIpnClient
-{
-    private readonly HttpClient _httpClient = new HttpClient();
-    private readonly Uri _ipnUri;
-    private readonly ILogger<PayPalIpnClient> _logger;
-
-    public PayPalIpnClient(IOptions<BillingSettings> billingSettings, ILogger<PayPalIpnClient> logger)
-    {
-        var bSettings = billingSettings?.Value;
-        _logger = logger;
-        _ipnUri = new Uri(bSettings.PayPal.Production ? "https://www.paypal.com/cgi-bin/webscr" :
-            "https://www.sandbox.paypal.com/cgi-bin/webscr");
-    }
-
-    public async Task<bool> VerifyIpnAsync(string ipnBody)
-    {
-        _logger.LogInformation("Verifying IPN with PayPal at {Timestamp}: {VerificationUri}", DateTime.UtcNow, _ipnUri);
-        if (ipnBody == null)
-        {
-            _logger.LogError("No IPN body.");
-            throw new ArgumentException("No IPN body.");
-        }
-
-        var request = new HttpRequestMessage { Method = HttpMethod.Post, RequestUri = _ipnUri };
-        var cmdIpnBody = string.Concat("cmd=_notify-validate&", ipnBody);
-        request.Content = new StringContent(cmdIpnBody, Encoding.UTF8, "application/x-www-form-urlencoded");
-        var response = await _httpClient.SendAsync(request);
-        if (!response.IsSuccessStatusCode)
-        {
-            _logger.LogError("Failed to receive a successful response from PayPal IPN verification service. Response: {Response}", response);
-            throw new Exception("Failed to verify IPN, status: " + response.StatusCode);
-        }
-
-        var responseContent = await response.Content.ReadAsStringAsync();
-        if (responseContent.Equals("VERIFIED"))
-        {
-            return true;
-        }
-
-        if (responseContent.Equals("INVALID"))
-        {
-            _logger.LogWarning("Received an INVALID response from PayPal: {ResponseContent}", responseContent);
-            return false;
-        }
-
-        _logger.LogError("Failed to verify IPN: {ResponseContent}", responseContent);
-        throw new Exception("Failed to verify IPN.");
-    }
-
-    public class IpnTransaction
-    {
-        private string[] _dateFormats = new string[]
-        {
-            "HH:mm:ss dd MMM yyyy PDT", "HH:mm:ss dd MMM yyyy PST", "HH:mm:ss dd MMM, yyyy PST",
-            "HH:mm:ss dd MMM, yyyy PDT","HH:mm:ss MMM dd, yyyy PST", "HH:mm:ss MMM dd, yyyy PDT"
-        };
-
-        public IpnTransaction(string ipnFormData)
-        {
-            if (string.IsNullOrWhiteSpace(ipnFormData))
-            {
-                return;
-            }
-
-            var qsData = HttpUtility.ParseQueryString(ipnFormData);
-            var dataDict = qsData.Keys.Cast<string>().ToDictionary(k => k, v => qsData[v].ToString());
-
-            TxnId = GetDictValue(dataDict, "txn_id");
-            TxnType = GetDictValue(dataDict, "txn_type");
-            ParentTxnId = GetDictValue(dataDict, "parent_txn_id");
-            PaymentStatus = GetDictValue(dataDict, "payment_status");
-            PaymentType = GetDictValue(dataDict, "payment_type");
-            McCurrency = GetDictValue(dataDict, "mc_currency");
-            Custom = GetDictValue(dataDict, "custom");
-            ItemName = GetDictValue(dataDict, "item_name");
-            ItemNumber = GetDictValue(dataDict, "item_number");
-            PayerId = GetDictValue(dataDict, "payer_id");
-            PayerEmail = GetDictValue(dataDict, "payer_email");
-            ReceiverId = GetDictValue(dataDict, "receiver_id");
-            ReceiverEmail = GetDictValue(dataDict, "receiver_email");
-
-            PaymentDate = ConvertDate(GetDictValue(dataDict, "payment_date"));
-
-            var mcGrossString = GetDictValue(dataDict, "mc_gross");
-            if (!string.IsNullOrWhiteSpace(mcGrossString) && decimal.TryParse(mcGrossString, out var mcGross))
-            {
-                McGross = mcGross;
-            }
-            var mcFeeString = GetDictValue(dataDict, "mc_fee");
-            if (!string.IsNullOrWhiteSpace(mcFeeString) && decimal.TryParse(mcFeeString, out var mcFee))
-            {
-                McFee = mcFee;
-            }
-        }
-
-        public string TxnId { get; set; }
-        public string TxnType { get; set; }
-        public string ParentTxnId { get; set; }
-        public string PaymentStatus { get; set; }
-        public string PaymentType { get; set; }
-        public decimal McGross { get; set; }
-        public decimal McFee { get; set; }
-        public string McCurrency { get; set; }
-        public string Custom { get; set; }
-        public string ItemName { get; set; }
-        public string ItemNumber { get; set; }
-        public string PayerId { get; set; }
-        public string PayerEmail { get; set; }
-        public string ReceiverId { get; set; }
-        public string ReceiverEmail { get; set; }
-        public DateTime PaymentDate { get; set; }
-
-        public Tuple<Guid?, Guid?> GetIdsFromCustom()
-        {
-            Guid? orgId = null;
-            Guid? userId = null;
-
-            if (!string.IsNullOrWhiteSpace(Custom) && Custom.Contains(":"))
-            {
-                var mainParts = Custom.Split(',');
-                foreach (var mainPart in mainParts)
-                {
-                    var parts = mainPart.Split(':');
-                    if (parts.Length > 1 && Guid.TryParse(parts[1], out var id))
-                    {
-                        if (parts[0] == "user_id")
-                        {
-                            userId = id;
-                        }
-                        else if (parts[0] == "organization_id")
-                        {
-                            orgId = id;
-                        }
-                    }
-                }
-            }
-
-            return new Tuple<Guid?, Guid?>(orgId, userId);
-        }
-
-        public bool IsAccountCredit()
-        {
-            return !string.IsNullOrWhiteSpace(Custom) && Custom.Contains("account_credit:1");
-        }
-
-        private string GetDictValue(IDictionary<string, string> dict, string key)
-        {
-            return dict.ContainsKey(key) ? dict[key] : null;
-        }
-
-        private DateTime ConvertDate(string dateString)
-        {
-            if (!string.IsNullOrWhiteSpace(dateString))
-            {
-                var parsed = DateTime.TryParseExact(dateString, _dateFormats,
-                    CultureInfo.InvariantCulture, DateTimeStyles.None, out var paymentDate);
-                if (parsed)
-                {
-                    var pacificTime = RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ?
-                        TimeZoneInfo.FindSystemTimeZoneById("Pacific Standard Time") :
-                        TimeZoneInfo.FindSystemTimeZoneById("America/Los_Angeles");
-                    return TimeZoneInfo.ConvertTimeToUtc(paymentDate, pacificTime);
-                }
-            }
-            return default(DateTime);
-        }
-    }
-}