change payment methods between stripe and paypal

src/Core/Models/Table/ISubscriber.cs

@@ -1,15 +1,18 @@
-using Bit.Core.Enums;
+using System;
+using Bit.Core.Enums;
 using Bit.Core.Services;
 
 namespace Bit.Core.Models.Table
 {
     public interface ISubscriber
     {
+        Guid Id { get; }
         GatewayType? Gateway { get; set; }
         string GatewayCustomerId { get; set; }
         string GatewaySubscriptionId { get; set; }
         string BillingEmailAddress();
         string BillingName();
+        string BraintreeCustomerIdPrefix();
         IPaymentService GetPaymentService(GlobalSettings globalSettings);
     }
 }

src/Core/Models/Table/Organization.cs

@@ -63,6 +63,11 @@ namespace Bit.Core.Models.Table
             return BusinessName;
         }
 
+        public string BraintreeCustomerIdPrefix()
+        {
+            return "o";
+        }
+
         public long StorageBytesRemaining()
         {
             if(!MaxStorageGb.HasValue)

src/Core/Models/Table/User.cs

@@ -58,6 +58,11 @@ namespace Bit.Core.Models.Table
             return Name;
         }
 
+        public string BraintreeCustomerIdPrefix()
+        {
+            return "u";
+        }
+
         public Dictionary<TwoFactorProviderType, TwoFactorProvider> GetTwoFactorProviders()
         {
             if(string.IsNullOrWhiteSpace(TwoFactorProviders))

src/Core/Services/IPaymentService.cs

@@ -13,7 +13,8 @@ namespace Bit.Core.Services
         Task AdjustStorageAsync(IStorableSubscriber storableSubscriber, int additionalStorage, string storagePlanId);
         Task CancelSubscriptionAsync(ISubscriber subscriber, bool endOfPeriod = false);
         Task ReinstateSubscriptionAsync(ISubscriber subscriber);
-        Task<bool> UpdatePaymentMethodAsync(ISubscriber subscriber, string paymentToken);
+        Task<bool> UpdatePaymentMethodAsync(ISubscriber subscriber, PaymentMethodType paymentMethodType,
+            string paymentToken);
         Task<BillingInfo.BillingInvoice> GetUpcomingInvoiceAsync(ISubscriber subscriber);
         Task<BillingInfo> GetBillingAsync(ISubscriber subscriber);
     }

src/Core/Services/Implementations/BraintreePaymentService.cs

@@ -303,14 +303,20 @@ namespace Bit.Core.Services
             }
         }
 
-        public async Task<bool> UpdatePaymentMethodAsync(ISubscriber subscriber, string paymentToken)
+        public async Task<bool> UpdatePaymentMethodAsync(ISubscriber subscriber, PaymentMethodType paymentMethodType,
+            string paymentToken)
         {
             if(subscriber == null)
             {
                 throw new ArgumentNullException(nameof(subscriber));
             }
 
-            if(subscriber.Gateway.HasValue && subscriber.Gateway.Value != Enums.GatewayType.Braintree)
+            if(paymentMethodType != PaymentMethodType.PayPal)
+            {
+                throw new GatewayException("Payment method not allowed");
+            }
+
+            if(subscriber.Gateway.HasValue && subscriber.Gateway.Value != GatewayType.Braintree)
             {
                 throw new GatewayException("Switching from one payment type to another is not supported. " +
                     "Contact us for assistance.");

src/Core/Services/Implementations/OrganizationService.cs

@@ -78,7 +78,22 @@ namespace Bit.Core.Services
                 throw new NotFoundException();
             }
 
-            var updated = await _stripePaymentService.UpdatePaymentMethodAsync(organization, paymentToken);
+            PaymentMethodType paymentMethodType;
+            if(paymentToken.StartsWith("btok_"))
+            {
+                paymentMethodType = PaymentMethodType.BankAccount;
+            }
+            else if(paymentToken.StartsWith("tok_"))
+            {
+                paymentMethodType = PaymentMethodType.Card;
+            }
+            else
+            {
+                paymentMethodType = PaymentMethodType.PayPal;
+            }
+
+            var updated = await _stripePaymentService.UpdatePaymentMethodAsync(organization,
+                paymentMethodType, paymentToken);
             if(updated)
             {
                 await ReplaceAndUpdateCache(organization);

src/Core/Services/Implementations/StripePaymentService.cs

@@ -65,6 +65,10 @@ namespace Bit.Core.Services
                 braintreeCustomer = customerResult.Target;
                 stripeCustomerMetadata.Add("btCustomerId", braintreeCustomer.Id);
             }
+            else
+            {
+                throw new GatewayException("Payment method is not supported at this time.");
+            }
 
             var customer = await customerService.CreateAsync(new CustomerCreateOptions
             {
@@ -542,20 +546,26 @@ namespace Bit.Core.Services
             }
         }
 
-        public async Task<bool> UpdatePaymentMethodAsync(ISubscriber subscriber, string paymentToken)
+        public async Task<bool> UpdatePaymentMethodAsync(ISubscriber subscriber, PaymentMethodType paymentMethodType,
+            string paymentToken)
         {
             if(subscriber == null)
             {
                 throw new ArgumentNullException(nameof(subscriber));
             }
 
-            if(subscriber.Gateway.HasValue && subscriber.Gateway.Value != Enums.GatewayType.Stripe)
+            if(subscriber.Gateway.HasValue && subscriber.Gateway.Value != GatewayType.Stripe)
             {
                 throw new GatewayException("Switching from one payment type to another is not supported. " +
                     "Contact us for assistance.");
             }
 
-            var updatedSubscriber = false;
+            var createdCustomer = false;
+            Braintree.Customer braintreeCustomer = null;
+            string stipeCustomerSourceToken = null;
+            var stripeCustomerMetadata = new Dictionary<string, string>();
+            var stripePaymentMethod = paymentMethodType == PaymentMethodType.Card ||
+                paymentMethodType == PaymentMethodType.BankAccount;
 
             var cardService = new CardService();
             var bankSerice = new BankAccountService();
@@ -565,53 +575,122 @@ namespace Bit.Core.Services
             if(!string.IsNullOrWhiteSpace(subscriber.GatewayCustomerId))
             {
                 customer = await customerService.GetAsync(subscriber.GatewayCustomerId);
+                if(customer.Metadata?.Any() ?? false)
+                {
+                    stripeCustomerMetadata = customer.Metadata;
+                }
             }
 
+            if(stripeCustomerMetadata.ContainsKey("btCustomerId"))
+            {
+                var nowSec = Utilities.CoreHelpers.ToEpocSeconds(DateTime.UtcNow);
+                stripeCustomerMetadata.Add($"btCustomerId_{nowSec}", stripeCustomerMetadata["btCustomerId"]);
+                stripeCustomerMetadata["btCustomerId"] = null;
+            }
+
+            if(stripePaymentMethod)
+            {
+                stipeCustomerSourceToken = paymentToken;
+            }
+            else if(paymentMethodType == PaymentMethodType.PayPal)
+            {
+                var randomSuffix = Utilities.CoreHelpers.RandomString(3, upper: false, numeric: false);
+                var customerResult = await _btGateway.Customer.CreateAsync(new Braintree.CustomerRequest
+                {
+                    PaymentMethodNonce = paymentToken,
+                    Email = subscriber.BillingEmailAddress(),
+                    Id = subscriber.BraintreeCustomerIdPrefix() + subscriber.Id.ToString("N").ToLower() + randomSuffix
+                });
+
+                if(!customerResult.IsSuccess() || customerResult.Target.PaymentMethods.Length == 0)
+                {
+                    throw new GatewayException("Failed to create PayPal customer record.");
+                }
+
+                braintreeCustomer = customerResult.Target;
+                if(stripeCustomerMetadata.ContainsKey("btCustomerId"))
+                {
+                    stripeCustomerMetadata["btCustomerId"] = braintreeCustomer.Id;
+                }
+                else
+                {
+                    stripeCustomerMetadata.Add("btCustomerId", braintreeCustomer.Id);
+                }
+            }
+            else
+            {
+                throw new GatewayException("Payment method is not supported at this time.");
+            }
+
+            try
+            {
                 if(customer == null)
                 {
                     customer = await customerService.CreateAsync(new CustomerCreateOptions
                     {
                         Description = subscriber.BillingName(),
                         Email = subscriber.BillingEmailAddress(),
-                    SourceToken = paymentToken
+                        SourceToken = stipeCustomerSourceToken,
+                        Metadata = stripeCustomerMetadata
                     });
 
-                subscriber.Gateway = Enums.GatewayType.Stripe;
+                    subscriber.Gateway = GatewayType.Stripe;
                     subscriber.GatewayCustomerId = customer.Id;
-                updatedSubscriber = true;
+                    createdCustomer = true;
                 }
-            else
+
+                if(!createdCustomer)
+                {
+                    string defaultSourceId = null;
+                    if(stripePaymentMethod)
                     {
                         if(paymentToken.StartsWith("btok_"))
                         {
-                    await bankSerice.CreateAsync(customer.Id, new BankAccountCreateOptions
+                            var bankAccount = await bankSerice.CreateAsync(customer.Id, new BankAccountCreateOptions
                             {
                                 SourceToken = paymentToken
                             });
+                            defaultSourceId = bankAccount.Id;
                         }
                         else
                         {
-                    await cardService.CreateAsync(customer.Id, new CardCreateOptions
+                            var card = await cardService.CreateAsync(customer.Id, new CardCreateOptions
                             {
-                        SourceToken = paymentToken
+                                SourceToken = paymentToken,
                             });
+                            defaultSourceId = card.Id;
+                        }
                     }
 
-                if(!string.IsNullOrWhiteSpace(customer.DefaultSourceId))
+                    foreach(var source in customer.Sources.Where(s => s.Id != defaultSourceId))
                     {
-                    var source = customer.Sources.FirstOrDefault(s => s.Id == customer.DefaultSourceId);
                         if(source is BankAccount)
                         {
-                        await bankSerice.DeleteAsync(customer.Id, customer.DefaultSourceId);
+                            await bankSerice.DeleteAsync(customer.Id, source.Id);
                         }
                         else if(source is Card)
                         {
-                        await cardService.DeleteAsync(customer.Id, customer.DefaultSourceId);
+                            await cardService.DeleteAsync(customer.Id, source.Id);
-                    }
                         }
                     }
 
-            return updatedSubscriber;
+                    customer = await customerService.UpdateAsync(customer.Id, new CustomerUpdateOptions
+                    {
+                        Metadata = stripeCustomerMetadata,
+                        DefaultSource = defaultSourceId
+                    });
+                }
+            }
+            catch(Exception e)
+            {
+                if(braintreeCustomer != null)
+                {
+                    await _btGateway.Customer.DeleteAsync(braintreeCustomer.Id);
+                }
+                throw e;
+            }
+
+            return createdCustomer;
         }
 
         public async Task<BillingInfo.BillingInvoice> GetUpcomingInvoiceAsync(ISubscriber subscriber)
@@ -660,13 +739,18 @@ namespace Bit.Core.Services
 
                     if(customer.Metadata?.ContainsKey("btCustomerId") ?? false)
                     {
-                        var braintreeCustomer = await _btGateway.Customer.FindAsync(customer.Metadata["btCustomerId"]);
+                        try
+                        {
+                            var braintreeCustomer = await _btGateway.Customer.FindAsync(
+                                customer.Metadata["btCustomerId"]);
                             if(braintreeCustomer?.DefaultPaymentMethod != null)
                             {
                                 billingInfo.PaymentSource = new BillingInfo.BillingSource(
                                     braintreeCustomer.DefaultPaymentMethod);
                             }
                         }
+                        catch(Braintree.Exceptions.NotFoundException) { }
+                    }
                     else if(!string.IsNullOrWhiteSpace(customer.DefaultSourceId) && customer.Sources?.Data != null)
                     {
                         if(customer.DefaultSourceId.StartsWith("card_") || customer.DefaultSourceId.StartsWith("ba_"))

src/Core/Services/Implementations/UserService.cs

@@ -800,17 +800,18 @@ namespace Bit.Core.Services
                 throw new BadRequestException("Invalid token.");
             }
 
-            IPaymentService paymentService = null;
+            PaymentMethodType paymentMethodType;
+            var paymentService = new StripePaymentService(_globalSettings);
             if(paymentToken.StartsWith("tok_"))
             {
-                paymentService = new StripePaymentService(_globalSettings);
+                paymentMethodType = PaymentMethodType.Card;
             }
             else
             {
-                paymentService = new BraintreePaymentService(_globalSettings);
+                paymentMethodType = PaymentMethodType.PayPal;
             }
 
-            var updated = await paymentService.UpdatePaymentMethodAsync(user, paymentToken);
+            var updated = await paymentService.UpdatePaymentMethodAsync(user, paymentMethodType, paymentToken);
             if(updated)
             {
                 await SaveUserAsync(user);