pay 2.7.1 → 3.0.2

data/lib/pay/stripe/charge.rb

@@ -3,35 +3,55 @@ 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)
-        object ||= ::Stripe::Charge.retrieve(id: charge_id)
-        owner = Pay.find_billable(processor: :stripe, processor_id: object.customer)
-        return unless owner
+      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(charge_id, {stripe_account: stripe_account}.compact)
 
+        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
 
-        pay_charge = owner.charges.find_or_initialize_by(processor: :stripe, processor_id: object.id)
-        pay_charge.update(attrs)
-        pay_charge
+        # Update or create the charge
+        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
+          pay_customer.charges.create!(attrs.merge(processor_id: object.id))
+        end
+      rescue ActiveRecord::RecordInvalid
+        try += 1
+        if try <= retries
+          sleep 0.1
+          retry
+        else
+          raise
+        end
       end
 
       def initialize(pay_charge)
@@ -39,7 +59,7 @@ module Pay
       end
 
       def charge
-        ::Stripe::Charge.retrieve({id: processor_id, expand: ["customer", "invoice.subscription"]}, {stripe_account: stripe_account})
+        ::Stripe::Charge.retrieve({id: processor_id, expand: ["customer", "invoice.subscription"]}, stripe_options)
       rescue ::Stripe::StripeError => e
         raise Pay::Stripe::Error, e
       end
@@ -50,11 +70,18 @@ module Pay
       # refund!(5_00)
       # refund!(5_00, refund_application_fee: true)
       def refund!(amount_to_refund, **options)
-        ::Stripe::Refund.create(options.merge(charge: processor_id, amount: amount_to_refund), {stripe_account: stripe_account})
+        ::Stripe::Refund.create(options.merge(charge: processor_id, amount: amount_to_refund), stripe_options)
         pay_charge.update(amount_refunded: amount_to_refund)
       rescue ::Stripe::StripeError => e
         raise Pay::Stripe::Error, e
       end
+
+      private
+
+      # Options for Stripe requests
+      def stripe_options
+        {stripe_account: stripe_account}.compact
+      end
     end
   end
 end

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,33 +19,56 @@ module Pay
         :trial_ends_at,
         to: :pay_subscription
 
-      def self.sync(subscription_id, object: nil, name: Pay.default_product_name)
+      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
         }
 
-        # Subscriptions cancelling in the future
-        attributes[:ends_at] = Time.at(object.current_period_end) if object.cancel_at_period_end
-
-        # Fully cancelled subscription
-        attributes[:ends_at] = Time.at(object.ended_at) if object.ended_at
+        attributes[:ends_at] = if object.ended_at
+          # Fully cancelled subscription
+          Time.at(object.ended_at)
+        elsif object.cancel_at
+          # subscription cancelling in the future
+          Time.at(object.cancel_at)
+        elsif object.cancel_at_period_end
+          # Subscriptions cancelling in the future
+          Time.at(object.current_period_end)
+        end
 
         # Update or create the subscription
-        pay_subscription = owner.subscriptions.find_or_initialize_by(processor: :stripe, processor_id: object.id)
-        pay_subscription.update(attributes)
+        pay_subscription = pay_customer.subscriptions.find_by(processor_id: object.id)
+        if pay_subscription
+          pay_subscription.with_lock { pay_subscription.update!(attributes) }
+        else
+          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
+          sleep 0.1
+          retry
+        else
+          raise
+        end
       end
 
       def initialize(pay_subscription)
@@ -54,31 +76,33 @@ 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
-        stripe_sub = ::Stripe::Subscription.update(processor_id, {cancel_at_period_end: true}, {stripe_account: stripe_account})
+        stripe_sub = ::Stripe::Subscription.update(processor_id, {cancel_at_period_end: true}, stripe_options)
         pay_subscription.update(ends_at: (on_trial? ? trial_ends_at : Time.at(stripe_sub.current_period_end)))
       rescue ::Stripe::StripeError => e
         raise Pay::Stripe::Error, e
       end
 
       def cancel_now!
-        ::Stripe::Subscription.delete(processor_id, {stripe_account: stripe_account})
+        ::Stripe::Subscription.delete(processor_id, {}, stripe_options)
         pay_subscription.update(ends_at: Time.current, status: :canceled)
       rescue ::Stripe::StripeError => e
         raise Pay::Stripe::Error, e
       end
 
       def change_quantity(quantity)
-        ::Stripe::Subscription.update(processor_id, quantity: quantity)
+        ::Stripe::Subscription.update(processor_id, {quantity: quantity}, stripe_options)
       rescue ::Stripe::StripeError => e
         raise Pay::Stripe::Error, e
       end
 
       def on_grace_period?
-        canceled? && Time.zone.now < ends_at
+        canceled? && Time.current < ends_at
       end
 
       def paused?
@@ -101,13 +125,15 @@ module Pay
             trial_end: (on_trial? ? trial_ends_at.to_i : "now"),
             cancel_at_period_end: false
           },
-          {stripe_account: stripe_account}
+          stripe_options
         )
       rescue ::Stripe::StripeError => e
         raise Pay::Stripe::Error, e
       end
 
       def swap(plan)
+        raise ArgumentError, "plan must be a string" unless plan.is_a?(String)
+
         ::Stripe::Subscription.update(
           processor_id,
           {
@@ -117,11 +143,18 @@ module Pay
             trial_end: (on_trial? ? trial_ends_at.to_i : "now"),
             quantity: quantity
           },
-          {stripe_account: stripe_account}
+          stripe_options
         )
       rescue ::Stripe::StripeError => e
         raise Pay::Stripe::Error, e
       end
+
+      private
+
+      # Options for Stripe requests
+      def stripe_options
+        {stripe_account: stripe_account}.compact
+      end
     end
   end
 end

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