pay 2.7.1 → 3.0.2

data/lib/pay/billable/sync_customer.rb

@@ -0,0 +1,30 @@
+module Pay
+  module Billable
+    module SyncCustomer
+      # Syncs customer details to the payment processor.
+      # This way they're kept in sync and email notifications are
+      # always sent to the correct email address after an update.
+
+      extend ActiveSupport::Concern
+
+      included do
+        after_update :enqeue_sync_email_job, if: :pay_should_sync_customer?
+      end
+
+      def pay_should_sync_customer?
+        try(:saved_change_to_email?)
+      end
+
+      private
+
+      def enqeue_sync_email_job
+        if saved_change_to_email?
+          # Queue job to update each payment processor for this customer
+          pay_customers.pluck(:id).each do |pay_customer_id|
+            CustomerSyncJob.perform_later(id)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pay/braintree/billable.rb

@@ -1,40 +1,42 @@
 module Pay
   module Braintree
     class Billable
-      attr_reader :billable
+      attr_reader :pay_customer
 
       delegate :processor_id,
         :processor_id?,
         :email,
         :customer_name,
-        :card_token,
-        to: :billable
+        :payment_method_token,
+        :payment_method_token?,
+        to: :pay_customer
 
-      def initialize(billable)
-        @billable = billable
+      def initialize(pay_customer)
+        @pay_customer = pay_customer
       end
 
-      # Handles Billable#customer
+      # Retrieve the Braintree::Customer object
       #
-      # Returns Braintree::Customer
+      # - If no processor_id is present, creates a Customer.
+      # - When 'payment_method_token' is present, it will also set the default payment method
       def customer
         if processor_id?
           customer = gateway.customer.find(processor_id)
-          update_card card_token if card_token.present?
+
+          if payment_method_token?
+            add_payment_method(payment_method_token, default: true)
+            pay_customer.payment_method_token = nil
+          end
+
           customer
         else
-          result = gateway.customer.create(
-            email: email,
-            first_name: try(:first_name),
-            last_name: try(:last_name),
-            payment_method_nonce: card_token
-          )
+          result = gateway.customer.create(email: email, first_name: try(:first_name), last_name: try(:last_name), payment_method_nonce: payment_method_token)
           raise Pay::Braintree::Error, result unless result.success?
+          pay_customer.update!(processor_id: result.customer.id)
 
-          billable.update(processor: "braintree", processor_id: result.customer.id)
-
-          if card_token.present?
-            update_card_on_file result.customer.payment_methods.last
+          if payment_method_token?
+            save_payment_method(result.customer.payment_methods.last, default: true)
+            pay_customer.payment_method_token = nil
           end
 
           result.customer
@@ -45,14 +47,12 @@ module Pay
         raise Pay::Braintree::Error, e
       end
 
-      # Handles Billable#charge
-      #
-      # Returns a Pay::Charge
       def charge(amount, options = {})
         args = {
           amount: amount.to_i / 100.0,
           customer_id: customer.id,
-          options: {submit_for_settlement: true}
+          options: {submit_for_settlement: true},
+          custom_fields: options.delete(:metadata)
         }.merge(options)
 
         result = gateway.transaction.sale(args)
@@ -65,9 +65,6 @@ module Pay
         raise Pay::Braintree::Error, e
       end
 
-      # Handles Billable#subscribe
-      #
-      # Returns Pay::Subscription
       def subscribe(name: Pay.default_product_name, plan: Pay.default_plan_name, **options)
         token = customer.payment_methods.find(&:default?).try(:token)
         raise Pay::Error, "Customer has no default payment method" if token.nil?
@@ -77,6 +74,7 @@ module Pay
           options.merge!(trial_period: true, trial_duration: trial_period_days, trial_duration_unit: :day)
         end
 
+        metadata = options.delete(:metadata)
         subscription_options = options.merge(
           payment_method_token: token,
           plan_id: plan
@@ -85,32 +83,44 @@ module Pay
         result = gateway.subscription.create(subscription_options)
         raise Pay::Braintree::Error, result unless result.success?
 
-        billable.create_pay_subscription(result.subscription, "braintree", name, plan, status: :active)
+        pay_customer.subscriptions.create!(
+          name: name,
+          processor_id: result.subscription.id,
+          processor_plan: plan,
+          status: :active,
+          trial_ends_at: trial_end_date(result.subscription),
+          ends_at: nil,
+          metadata: metadata
+        )
       rescue ::Braintree::AuthorizationError => e
         raise Pay::Braintree::AuthorizationError, e
       rescue ::Braintree::BraintreeError => e
         raise Pay::Braintree::Error, e
       end
 
-      # Handles Billable#update_card
-      #
-      # Returns true if successful
-      def update_card(token)
+      def add_payment_method(token, default: false)
         customer unless processor_id?
 
         result = gateway.payment_method.create(
           customer_id: processor_id,
           payment_method_nonce: token,
           options: {
-            make_default: true,
+            make_default: default,
             verify_card: true
           }
         )
         raise Pay::Braintree::Error, result unless result.success?
 
-        update_card_on_file result.payment_method
-        update_subscriptions_to_payment_method(result.payment_method.token)
-        true
+        pay_payment_method = save_payment_method(result.payment_method, default: default)
+
+        # Update existing subscriptions to the new payment method
+        pay_customer.subscriptions.each do |subscription|
+          if subscription.active?
+            gateway.subscription.update(subscription.processor_id, {payment_method_token: token})
+          end
+        end
+
+        pay_payment_method
       rescue ::Braintree::AuthorizationError => e
         raise Pay::Braintree::AuthorizationError, e
       rescue ::Braintree::BraintreeError => e
@@ -127,119 +137,132 @@ module Pay
         subscription.first_billing_date.end_of_day
       end
 
-      def update_subscriptions_to_payment_method(token)
-        billable.subscriptions.braintree.each do |subscription|
-          if subscription.active?
-            gateway.subscription.update(subscription.processor_id, {payment_method_token: token})
-          end
-        end
-      end
-
       def processor_subscription(subscription_id, options = {})
         gateway.subscription.find(subscription_id)
       end
 
-      def braintree_invoice!(options = {})
-        # pass
-      end
-
-      def braintree_upcoming_invoice
-        # pass
-      end
-
       def save_transaction(transaction)
         attrs = card_details_for_braintree_transaction(transaction)
         attrs[:amount] = transaction.amount.to_f * 100
+        attrs[:metadata] = transaction.custom_fields
+        attrs[:currency] = transaction.currency_iso_code
+        attrs[:application_fee_amount] = transaction.service_fee_amount
 
         # Associate charge with subscription if we can
         if transaction.subscription_id
-          attrs[:subscription] = Pay::Subscription.find_by(processor: :braintree, processor_id: transaction.subscription_id)
+          pay_subscription = pay_customer.subscriptions.find_by(processor_id: transaction.subscription_id)
+          attrs[:subscription] = pay_subscription
+          attrs[:metadata] = pay_subscription.metadata
         end
 
-        charge = billable.charges.find_or_initialize_by(
-          processor: :braintree,
-          processor_id: transaction.id,
-          currency: transaction.currency_iso_code,
-          application_fee_amount: transaction.service_fee_amount
-        )
-        charge.update(attrs)
+        charge = pay_customer.charges.find_or_initialize_by(processor_id: transaction.id)
+        charge.update!(attrs)
         charge
       end
 
-      private
-
       def gateway
         Pay.braintree_gateway
       end
 
-      def update_card_on_file(payment_method)
-        case payment_method
-        when ::Braintree::CreditCard
-          billable.update!(
-            card_type: payment_method.card_type,
-            card_last4: payment_method.last_4,
-            card_exp_month: payment_method.expiration_month,
-            card_exp_year: payment_method.expiration_year
-          )
-
-        when ::Braintree::PayPalAccount
-          billable.update!(
-            card_type: "PayPal",
-            card_last4: payment_method.email
-          )
+      def save_payment_method(payment_method, default:)
+        attributes = case payment_method
+                     when ::Braintree::CreditCard, ::Braintree::ApplePayCard, ::Braintree::GooglePayCard, ::Braintree::SamsungPayCard, ::Braintree::VisaCheckoutCard
+                       {
+                         payment_method_type: :card,
+                         brand: payment_method.card_type,
+                         last4: payment_method.last_4,
+                         exp_month: payment_method.expiration_month,
+                         exp_year: payment_method.expiration_year
+                       }
+
+                     when ::Braintree::PayPalAccount
+                       {
+                         payment_method_type: :paypal,
+                         brand: "PayPal",
+                         email: payment_method.email
+                       }
+                     when ::Braintree::VenmoAccount
+                       {
+                         payment_method_type: :venmo,
+                         brand: "Venmo",
+                         username: payment_method.username
+                       }
+                     when ::Braintree::UsBankAccount
+                       {
+                         payment_method_type: "us_bank_account",
+                         bank: payment_method.bank_name,
+                         last4: payment_method.last_4
+                       }
+                     else
+                       {
+                         payment_method_type: payment_method.class.name.demodulize.underscore,
+                         brand: payment_method.try(:card_type),
+                         last4: payment_method.try(:last_4),
+                         exp_month: payment_method.try(:expiration_month),
+                         exp_year: payment_method.try(:expiration_year),
+                         bank: payment_method.try(:bank_name),
+                         username: payment_method.try(:username),
+                         email: payment_method.try(:email)
+                       }
         end
 
-        # Clear the card token so we don't accidentally update twice
-        billable.card_token = nil
+        pay_payment_method = pay_customer.payment_methods.where(processor_id: payment_method.token).first_or_initialize
+
+        pay_customer.payment_methods.update_all(default: false) if default
+        pay_payment_method.update!(attributes.merge(default: default))
+
+        # Reload the Rails association
+        pay_customer.reload_default_payment_method if default
+
+        pay_payment_method
       end
 
       def card_details_for_braintree_transaction(transaction)
         case transaction.payment_instrument_type
-        when "credit_card", "samsung_pay_card", "masterpass_card", "visa_checkout_card"
-          payment_method = transaction.send("#{transaction.payment_instrument_type}_details")
-          {
-            card_type: payment_method.card_type,
-            card_last4: payment_method.last_4,
-            card_exp_month: payment_method.expiration_month,
-            card_exp_year: payment_method.expiration_year
-          }
+        when "android_pay_card", "apple_pay_card", "credit_card", "google_pay_card", "samsung_pay_card", "visa_checkout_card"
+          # Lookup the attribute with the payment method details by name
+          attribute_name = transaction.payment_instrument_type
 
-        when "paypal_account"
-          {
-            card_type: "PayPal",
-            card_last4: transaction.paypal_details.payer_email,
-            card_exp_month: nil,
-            card_exp_year: nil
-          }
+          # The attribute name for Apple and Google Pay don't include _card for some reason
+          if ["apple_pay_card", "google_pay_card"].include?(transaction.payment_instrument_type)
+            attribute_name = attribute_name.split("_card").first
+
+          # Android Pay was renamed to Google Pay, but test nonces still use android_pay_card
+          elsif attribute_name == "android_pay_card"
+            attribute_name = "google_pay"
+          end
+
+          # Retrieve payment method details from transaction
+          payment_method = transaction.send("#{attribute_name}_details")
 
-        when "android_pay_card"
-          payment_method = transaction.android_pay_details
           {
-            card_type: payment_method.source_card_type,
-            card_last4: payment_method.source_card_last_4,
-            card_exp_month: payment_method.expiration_month,
-            card_exp_year: payment_method.expiration_year
+            payment_method_type: :card,
+            brand: payment_method.card_type,
+            last4: payment_method.last_4,
+            exp_month: payment_method.expiration_month,
+            exp_year: payment_method.expiration_year
           }
 
-        when "venmo_account"
+        when "paypal_account"
           {
-            card_type: "Venmo",
-            card_last4: transaction.venmo_account_details.username,
-            card_exp_month: nil,
-            card_exp_year: nil
+            payment_method_type: :paypal,
+            brand: "PayPal",
+            last4: transaction.paypal_details.payer_email,
+            exp_month: nil,
+            exp_year: nil
           }
 
-        when "apple_pay_card"
-          payment_method = transaction.apple_pay_details
+        when "venmo_account"
           {
-            card_type: payment_method.card_type,
-            card_last4: payment_method.last_4,
-            card_exp_month: payment_method.expiration_month,
-            card_exp_year: payment_method.expiration_year
+            payment_method_type: :venmo,
+            brand: "Venmo",
+            last4: transaction.venmo_account_details.username,
+            exp_month: nil,
+            exp_year: nil
           }
 
         else
-          {}
+          {payment_method_type: "unknown"}
         end
       end
     end

data/lib/pay/braintree/payment_method.rb

@@ -0,0 +1,42 @@
+module Pay
+  module Braintree
+    class PaymentMethod
+      attr_reader :pay_payment_method
+
+      delegate :customer, :processor_id, to: :pay_payment_method
+
+      def self.sync(id, object: nil, try: 0, retries: 1)
+        object ||= gateway.payment_method.find(id)
+
+        pay_customer = Pay::Customer.find_by(processor: :braintree, processor_id: object.customer_id)
+        return unless pay_customer
+
+        pay_customer.save_payment_method(object, default: object.default?)
+      end
+
+      def initialize(pay_payment_method)
+        @pay_payment_method = pay_payment_method
+      end
+
+      # Sets payment method as default on Stripe
+      def make_default!
+        result = gateway.customer.update(customer.processor_id, default_payment_method_token: processor_id)
+        raise Pay::Braintree::Error, result unless result.success?
+        result.success?
+      end
+
+      # Remove payment method
+      def detach
+        result = gateway.payment_method.delete(processor_id)
+        raise Pay::Braintree::Error, result unless result.success?
+        result.success?
+      end
+
+      private
+
+      def gateway
+        Pay.braintree_gateway
+      end
+    end
+  end
+end

data/lib/pay/braintree/subscription.rb

@@ -4,11 +4,11 @@ module Pay
       attr_reader :pay_subscription
 
       delegate :active?,
+        :customer,
         :canceled?,
         :ends_at,
         :name,
         :on_trial?,
-        :owner,
         :processor_id,
         :processor_plan,
         :processor_subscription,
@@ -45,13 +45,13 @@ module Pay
 
       def cancel_now!
         gateway.subscription.cancel(processor_subscription.id)
-        pay_subscription.update(status: :canceled, ends_at: Time.zone.now)
+        pay_subscription.update(status: :canceled, ends_at: Time.current)
       rescue ::Braintree::BraintreeError => e
         raise Pay::Braintree::Error, e
       end
 
       def on_grace_period?
-        canceled? && Time.zone.now < ends_at
+        canceled? && Time.current < ends_at
       end
 
       def paused?
@@ -70,7 +70,7 @@ module Pay
         if canceled? && on_trial?
           duration = trial_ends_at.to_date - Date.today
 
-          owner.subscribe(
+          customer.subscribe(
             name: name,
             plan: processor_plan,
             trial_period: true,
@@ -92,13 +92,15 @@ module Pay
       end
 
       def swap(plan)
+        raise ArgumentError, "plan must be a string" unless plan.is_a?(String)
+
         if on_grace_period? && processor_plan == plan
           resume
           return
         end
 
         unless active?
-          owner.subscribe(name: name, plan: plan, trial_period: false)
+          customer.subscribe(name: name, plan: plan, trial_period: false)
           return
         end
 
@@ -120,12 +122,7 @@ module Pay
             prorate_charges: prorate?
           }
         })
-
-        if result.success?
-          pay_subscription.update(status: :active, processor_plan: braintree_plan.id, ends_at: nil)
-        else
-          raise Error, "Braintree failed to swap plans: #{result.message}"
-        end
+        raise Error, "Braintree failed to swap plans: #{result.message}" unless result.success?
       rescue ::Braintree::BraintreeError => e
         raise Pay::Braintree::Error, e
       end
@@ -205,7 +202,7 @@ module Pay
 
         cancel_now!
 
-        owner.subscribe(**options.merge(name: name, plan: plan.id))
+        customer.subscribe(**options.merge(name: name, plan: plan.id))
       end
     end
   end