pay 2.7.2 → 3.0.0

data/lib/pay/stripe/charge.rb

@@ -3,43 +3,46 @@ module Pay
     class Charge
       attr_reader :pay_charge
 
-      delegate :processor_id, :owner, :stripe_account, to: :pay_charge
+      delegate :processor_id, :stripe_account, to: :pay_charge
 
-      def self.sync(charge_id, object: nil, try: 0, retries: 1)
+      def self.sync(charge_id, object: nil, stripe_account: nil, try: 0, retries: 1)
         # Skip loading the latest charge details from the API if we already have it
-        object ||= ::Stripe::Charge.retrieve(id: charge_id)
+        object ||= ::Stripe::Charge.retrieve(charge_id, {stripe_account: stripe_account}.compact)
 
-        owner = Pay.find_billable(processor: :stripe, processor_id: object.customer)
-        return unless owner
+        pay_customer = Pay::Customer.find_by(processor: :stripe, processor_id: object.customer)
+        return unless pay_customer
 
+        payment_method = object.payment_method_details.send(object.payment_method_details.type)
         attrs = {
           amount: object.amount,
           amount_refunded: object.amount_refunded,
           application_fee_amount: object.application_fee_amount,
-          card_exp_month: object.payment_method_details.card.exp_month,
-          card_exp_year: object.payment_method_details.card.exp_year,
-          card_last4: object.payment_method_details.card.last4,
-          card_type: object.payment_method_details.card.brand,
           created_at: Time.at(object.created),
           currency: object.currency,
-          stripe_account: owner.stripe_account
+          stripe_account: pay_customer.stripe_account,
+          metadata: object.metadata,
+          payment_method_type: object.payment_method_details.type,
+          brand: payment_method.try(:brand)&.capitalize,
+          last4: payment_method.try(:last4).to_s,
+          exp_month: payment_method.try(:exp_month).to_s,
+          exp_year: payment_method.try(:exp_year).to_s,
+          bank: payment_method.try(:bank_name) || payment_method.try(:bank) # eps, fpx, ideal, p24, acss_debit, etc
         }
 
         # Associate charge with subscription if we can
         if object.invoice
-          invoice = (object.invoice.is_a?(::Stripe::Invoice) ? object.invoice : ::Stripe::Invoice.retrieve(object.invoice))
-          attrs[:subscription] = Pay::Subscription.find_by(processor: :stripe, processor_id: invoice.subscription)
+          invoice = (object.invoice.is_a?(::Stripe::Invoice) ? object.invoice : ::Stripe::Invoice.retrieve(object.invoice, {stripe_account: stripe_account}.compact))
+          attrs[:subscription] = pay_customer.subscriptions.find_by(processor_id: invoice.subscription)
         end
 
         # Update or create the charge
-        processor_details = {processor: :stripe, processor_id: object.id}
-        if (pay_charge = owner.charges.find_by(processor_details))
+        if (pay_charge = pay_customer.charges.find_by(processor_id: object.id))
           pay_charge.with_lock do
             pay_charge.update!(attrs)
           end
           pay_charge
         else
-          owner.charges.create!(attrs.merge(processor_details))
+          pay_customer.charges.create!(attrs.merge(processor_id: object.id))
         end
       rescue ActiveRecord::RecordInvalid
         try += 1

data/lib/pay/stripe/merchant.rb

@@ -1,13 +1,13 @@
 module Pay
   module Stripe
     class Merchant
-      attr_reader :merchant
+      attr_reader :pay_merchant
 
-      delegate :stripe_connect_account_id,
-        to: :merchant
+      delegate :processor_id,
+        to: :pay_merchant
 
-      def initialize(merchant)
-        @merchant = merchant
+      def initialize(pay_merchant)
+        @pay_merchant = pay_merchant
       end
 
       def create_account(**options)
@@ -20,21 +20,21 @@ module Pay
         }
 
         stripe_account = ::Stripe::Account.create(defaults.merge(options))
-        merchant.update(stripe_connect_account_id: stripe_account.id)
+        pay_merchant.update(processor_id: stripe_account.id)
         stripe_account
       rescue ::Stripe::StripeError => e
         raise Pay::Stripe::Error, e
       end
 
       def account
-        ::Stripe::Account.retrieve(stripe_connect_account_id)
+        ::Stripe::Account.retrieve(processor_id)
       rescue ::Stripe::StripeError => e
         raise Pay::Stripe::Error, e
       end
 
       def account_link(refresh_url:, return_url:, type: "account_onboarding", **options)
         ::Stripe::AccountLink.create({
-          account: stripe_connect_account_id,
+          account: processor_id,
           refresh_url: refresh_url,
           return_url: return_url,
           type: type
@@ -45,7 +45,7 @@ module Pay
 
       # A single-use login link for Express accounts to access their Stripe dashboard
       def login_link(**options)
-        ::Stripe::Account.create_login_link(stripe_connect_account_id)
+        ::Stripe::Account.create_login_link(processor_id)
       rescue ::Stripe::StripeError => e
         raise Pay::Stripe::Error, e
       end
@@ -56,7 +56,7 @@ module Pay
         ::Stripe::Transfer.create({
           amount: amount,
           currency: currency,
-          destination: stripe_connect_account_id
+          destination: processor_id
         }.merge(options))
       rescue ::Stripe::StripeError => e
         raise Pay::Stripe::Error, e

data/lib/pay/stripe/payment_method.rb

@@ -0,0 +1,61 @@
+module Pay
+  module Stripe
+    class PaymentMethod
+      attr_reader :pay_payment_method
+
+      delegate :customer, :processor_id, to: :pay_payment_method
+
+      def initialize(pay_payment_method)
+        @pay_payment_method = pay_payment_method
+      end
+
+      def self.sync(id, object: nil, stripe_account: nil, try: 0, retries: 1)
+        object ||= ::Stripe::PaymentMethod.retrieve(id, {stripe_account: stripe_account}.compact)
+
+        pay_customer = Pay::Customer.find_by(processor: :stripe, processor_id: object.customer)
+        return unless pay_customer
+
+        default_payment_method_id = pay_customer.customer.invoice_settings.default_payment_method
+        default = (id == default_payment_method_id)
+
+        attributes = extract_attributes(object).merge(default: default)
+
+        pay_customer.payment_methods.update_all(default: false) if default
+        pay_payment_method = pay_customer.payment_methods.where(processor_id: object.id).first_or_initialize
+        pay_payment_method.update!(attributes)
+        pay_payment_method
+      end
+
+      # Extracts payment method details from a Stripe::PaymentMethod object
+      def self.extract_attributes(payment_method)
+        details = payment_method.send(payment_method.type)
+
+        {
+          payment_method_type: payment_method.type,
+          brand: details.try(:brand)&.capitalize,
+          last4: details.try(:last4).to_s,
+          exp_month: details.try(:exp_month).to_s,
+          exp_year: details.try(:exp_year).to_s,
+          bank: details.try(:bank_name) || details.try(:bank) # eps, fpx, ideal, p24, acss_debit, etc
+        }
+      end
+
+      # Sets payment method as default
+      def make_default!
+        ::Stripe::Customer.update(customer.processor_id, {invoice_settings: {default_payment_method: processor_id}}, stripe_options)
+      end
+
+      # Remove payment method
+      def detach
+        ::Stripe::PaymentMethod.detach(processor_id, stripe_options)
+      end
+
+      private
+
+      # Options for Stripe requests
+      def stripe_options
+        {stripe_account: customer.stripe_account}.compact
+      end
+    end
+  end
+end

data/lib/pay/stripe/subscription.rb

@@ -8,7 +8,6 @@ module Pay
         :ends_at,
         :name,
         :on_trial?,
-        :owner,
         :processor_id,
         :processor_plan,
         :processor_subscription,
@@ -20,21 +19,21 @@ module Pay
         :trial_ends_at,
         to: :pay_subscription
 
-      def self.sync(subscription_id, object: nil, name: Pay.default_product_name, try: 0, retries: 1)
+      def self.sync(subscription_id, object: nil, name: Pay.default_product_name, stripe_account: nil, try: 0, retries: 1)
         # Skip loading the latest subscription details from the API if we already have it
-        object ||= ::Stripe::Subscription.retrieve({id: subscription_id, expand: ["pending_setup_intent", "latest_invoice.payment_intent"]})
+        object ||= ::Stripe::Subscription.retrieve({id: subscription_id, expand: ["pending_setup_intent", "latest_invoice.payment_intent", "latest_invoice.charge.invoice"]}, {stripe_account: stripe_account}.compact)
 
-        owner = Pay.find_billable(processor: :stripe, processor_id: object.customer)
-        return unless owner
+        pay_customer = Pay::Customer.find_by(processor: :stripe, processor_id: object.customer)
+        return unless pay_customer
 
         attributes = {
           application_fee_percent: object.application_fee_percent,
           processor_plan: object.plan.id,
           quantity: object.quantity,
-          name: name,
           status: object.status,
-          stripe_account: owner.stripe_account,
-          trial_ends_at: (object.trial_end ? Time.at(object.trial_end) : nil)
+          stripe_account: pay_customer.stripe_account,
+          trial_ends_at: (object.trial_end ? Time.at(object.trial_end) : nil),
+          metadata: object.metadata
         }
 
         attributes[:ends_at] = if object.ended_at
@@ -49,15 +48,19 @@ module Pay
         end
 
         # Update or create the subscription
-        processor_details = {processor: :stripe, processor_id: object.id}
-        if (pay_subscription = owner.subscriptions.find_by(processor_details))
-          pay_subscription.with_lock do
-            pay_subscription.update!(attributes)
-          end
-          pay_subscription
+        pay_subscription = pay_customer.subscriptions.find_by(processor_id: object.id)
+        if pay_subscription
+          pay_subscription.with_lock { pay_subscription.update!(attributes) }
         else
-          owner.subscriptions.create!(attributes.merge(processor_details))
+          pay_subscription = pay_customer.subscriptions.create!(attributes.merge(name: name, processor_id: object.id))
         end
+
+        # Sync the latest charge if we already have it loaded (like during subscrbe), otherwise, let webhooks take care of creating it
+        if (charge = object.try(:latest_invoice).try(:charge)) && charge.try(:status) == "succeeded"
+          Pay::Stripe::Charge.sync(charge.id, object: charge)
+        end
+
+        pay_subscription
       rescue ActiveRecord::RecordInvalid
         try += 1
         if try <= retries
@@ -73,7 +76,9 @@ module Pay
       end
 
       def subscription(**options)
-        ::Stripe::Subscription.retrieve(options.merge(id: processor_id))
+        options[:id] = processor_id
+        options[:expand] ||= ["pending_setup_intent", "latest_invoice.payment_intent", "latest_invoice.charge.invoice"]
+        ::Stripe::Subscription.retrieve(options, {stripe_account: stripe_account}.compact)
       end
 
       def cancel
@@ -97,7 +102,7 @@ module Pay
       end
 
       def on_grace_period?
-        canceled? && Time.zone.now < ends_at
+        canceled? && Time.current < ends_at
       end
 
       def paused?

data/lib/pay/stripe/webhooks/account_updated.rb

@@ -5,9 +5,8 @@ module Pay
         def call(event)
           object = event.data.object
 
-          merchant = Pay.find_merchant("stripe_connect_account_id", object.id)
-
-          return unless merchant.present?
+          merchant = Pay::Merchant.find_by(processor: :stripe, processor_id: object.id)
+          return unless merchant
 
           merchant.update(onboarding_complete: object.charges_enabled)
         end

data/lib/pay/stripe/webhooks/charge_refunded.rb

@@ -3,7 +3,7 @@ module Pay
     module Webhooks
       class ChargeRefunded
         def call(event)
-          pay_charge = Pay::Stripe::Charge.sync(event.data.object.id)
+          pay_charge = Pay::Stripe::Charge.sync(event.data.object.id, stripe_account: event.try(:account))
           notify_user(pay_charge.owner, pay_charge) if pay_charge
         end
 

data/lib/pay/stripe/webhooks/charge_succeeded.rb

@@ -3,8 +3,8 @@ module Pay
     module Webhooks
       class ChargeSucceeded
         def call(event)
-          pay_charge = Pay::Stripe::Charge.sync(event.data.object.id)
-          notify_user(pay_charge.owner, pay_charge) if pay_charge
+          pay_charge = Pay::Stripe::Charge.sync(event.data.object.id, stripe_account: event.try(:account))
+          notify_user(pay_charge.customer.owner, pay_charge) if pay_charge
         end
 
         def notify_user(billable, charge)

data/lib/pay/stripe/webhooks/checkout_session_async_payment_succeeded.rb

@@ -3,8 +3,10 @@ module Pay
     module Webhooks
       class CheckoutSessionAsyncPaymentSucceeded
         def call(event)
+          # TODO: Also handle payment intents
+
           if event.data.object.subscription
-            Pay::Stripe::Subscription.sync(event.data.object.subscription)
+            Pay::Stripe::Subscription.sync(event.data.object.subscription, stripe_account: event.try(:account))
           end
         end
       end

data/lib/pay/stripe/webhooks/checkout_session_completed.rb

@@ -3,8 +3,10 @@ module Pay
     module Webhooks
       class CheckoutSessionCompleted
         def call(event)
+          # TODO: Also handle payment intents
+
           if event.data.object.subscription
-            Pay::Stripe::Subscription.sync(event.data.object.subscription)
+            Pay::Stripe::Subscription.sync(event.data.object.subscription, stripe_account: event.try(:account))
           end
         end
       end

data/lib/pay/stripe/webhooks/customer_deleted.rb

@@ -4,24 +4,16 @@ module Pay
       class CustomerDeleted
         def call(event)
           object = event.data.object
-          billable = Pay.find_billable(processor: :stripe, processor_id: object.id)
+          pay_customer = Pay::Customer.find_by(processor: :stripe, processor_id: object.id)
 
-          # Couldn't find user, we can skip
-          return unless billable.present?
+          # Mark all subscriptions as canceled
+          pay_customer.subscriptions.active.update_all(ends_at: Time.current, status: "canceled")
 
-          billable.update(
-            processor_id: nil,
-            trial_ends_at: nil,
-            card_type: nil,
-            card_last4: nil,
-            card_exp_month: nil,
-            card_exp_year: nil
-          )
+          # Remove all payment methods
+          pay_customer.payment_methods.destroy_all
 
-          billable.subscriptions.update_all(
-            trial_ends_at: nil,
-            ends_at: Time.zone.now
-          )
+          # Mark customer as deleted
+          pay_customer&.update!(default: false, deleted_at: Time.current)
         end
       end
     end

data/lib/pay/stripe/webhooks/customer_updated.rb

@@ -4,12 +4,19 @@ module Pay
       class CustomerUpdated
         def call(event)
           object = event.data.object
-          billable = Pay.find_billable(processor: :stripe, processor_id: object.id)
+          pay_customer = Pay::Customer.find_by(processor: :stripe, processor_id: object.id)
 
           # Couldn't find user, we can skip
-          return unless billable.present?
+          return unless pay_customer.present?
 
-          Pay::Stripe::Billable.new(billable).sync_card_from_stripe
+          # Sync default card
+          if (payment_method_id = pay_customer.customer.invoice_settings.default_payment_method)
+            Pay::Stripe::PaymentMethod.sync(payment_method_id, {stripe_account: event.account}.compact)
+
+          else
+            # No default payment method set
+            pay_customer.payment_methods.update_all(default: false)
+          end
         end
       end
     end

data/lib/pay/stripe/webhooks/payment_action_required.rb

@@ -8,9 +8,9 @@ module Pay
 
           object = event.data.object
 
-          subscription = Pay.subscription_model.find_by(processor: :stripe, processor_id: object.subscription)
+          subscription = Pay::Subscription.find_by_processor_and_id(:stripe, object.subscription)
           return if subscription.nil?
-          billable = subscription.owner
+          billable = subscription.customer.owner
 
           notify_user(billable, event.data.object.payment_intent, subscription)
         end

data/lib/pay/stripe/webhooks/payment_intent_succeeded.rb

@@ -2,17 +2,15 @@ module Pay
   module Stripe
     module Webhooks
       class PaymentIntentSucceeded
+        # This webhook does NOT send notifications because stripe sends both
+        # `charge.succeeded` and `payment_intent.succeeded` events.
+        #
+        # We use `charge.succeeded` as the single place to send notifications
+
         def call(event)
           object = event.data.object
           object.charges.data.each do |charge|
-            pay_charge = Pay::Stripe::Charge.sync(charge.id)
-            notify_user(pay_charge.owner, pay_charge) if pay_charge
-          end
-        end
-
-        def notify_user(billable, charge)
-          if Pay.send_emails && charge.respond_to?(:receipt)
-            Pay::UserMailer.with(billable: billable, charge: charge).receipt.deliver_later
+            Pay::Stripe::Charge.sync(charge.id, stripe_account: event.try(:account))
           end
         end
       end

data/lib/pay/stripe/webhooks/payment_method_attached.rb

@@ -5,11 +5,9 @@ module Pay
         def call(event)
           object = event.data.object
           pay_customer = Pay::Customer.find_by(processor: :stripe, processor_id: object.customer)
+          return unless pay_customer
 
-          # Couldn't find user, we can skip
-          return unless pay_customer.present?
-
-          Pay::Stripe::Billable.new(pay_customer).sync_payment_method(payment_method_id: object.id)
+          pay_customer.save_payment_method(object, default: false)
         end
       end
     end

data/lib/pay/stripe/webhooks/payment_method_detached.rb

@@ -4,12 +4,7 @@ module Pay
       class PaymentMethodDetached
         def call(event)
           object = event.data.object
-          pay_customer = Pay::Customer.find_by(processor: :stripe, processor_id: object.customer)
-
-          # Couldn't find user, we can skip
-          return unless pay_customer.present?
-
-          Pay::Stripe::Billable.new(pay_customer).sync_payment_method(payment_method_id: object.id)
+          Pay::PaymentMethod.find_by_processor_and_id(:stripe, object.id)&.destroy
         end
       end
     end