pay 2.6.11 → 3.0.0

data/lib/pay/stripe/merchant.rb

@@ -0,0 +1,66 @@
+module Pay
+  module Stripe
+    class Merchant
+      attr_reader :pay_merchant
+
+      delegate :processor_id,
+        to: :pay_merchant
+
+      def initialize(pay_merchant)
+        @pay_merchant = pay_merchant
+      end
+
+      def create_account(**options)
+        defaults = {
+          type: "express",
+          capabilities: {
+            card_payments: {requested: true},
+            transfers: {requested: true}
+          }
+        }
+
+        stripe_account = ::Stripe::Account.create(defaults.merge(options))
+        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(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: processor_id,
+          refresh_url: refresh_url,
+          return_url: return_url,
+          type: type
+        })
+      rescue ::Stripe::StripeError => e
+        raise Pay::Stripe::Error, e
+      end
+
+      # A single-use login link for Express accounts to access their Stripe dashboard
+      def login_link(**options)
+        ::Stripe::Account.create_login_link(processor_id)
+      rescue ::Stripe::StripeError => e
+        raise Pay::Stripe::Error, e
+      end
+
+      # Transfer money from the platform to this connected account
+      # https://stripe.com/docs/connect/charges-transfers#transfer-availability
+      def transfer(amount:, currency: "usd", **options)
+        ::Stripe::Transfer.create({
+          amount: amount,
+          currency: currency,
+          destination: processor_id
+        }.merge(options))
+      rescue ::Stripe::StripeError => e
+        raise Pay::Stripe::Error, e
+      end
+    end
+  end
+end

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,
@@ -16,43 +15,94 @@ module Pay
         :prorate?,
         :quantity,
         :quantity?,
+        :stripe_account,
         :trial_ends_at,
         to: :pay_subscription
 
+      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", "latest_invoice.charge.invoice"]}, {stripe_account: stripe_account}.compact)
+
+        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,
+          status: object.status,
+          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
+          # 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 = 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)
         @pay_subscription = pay_subscription
       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
-        subscription = processor_subscription
-        subscription.cancel_at_period_end = true
-        subscription.save
-
-        new_ends_at = on_trial? ? trial_ends_at : Time.at(subscription.current_period_end)
-        pay_subscription.update(ends_at: new_ends_at)
+        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!
-        processor_subscription.delete
-        pay_subscription.update(ends_at: Time.zone.now, status: :canceled)
+        ::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?
@@ -68,26 +118,43 @@ module Pay
           raise StandardError, "You can only resume subscriptions within their grace period."
         end
 
-        subscription = processor_subscription
-        subscription.plan = processor_plan
-        subscription.trial_end = on_trial? ? trial_ends_at.to_i : "now"
-        subscription.cancel_at_period_end = false
-        subscription.save
+        ::Stripe::Subscription.update(
+          processor_id,
+          {
+            plan: processor_plan,
+            trial_end: (on_trial? ? trial_ends_at.to_i : "now"),
+            cancel_at_period_end: false
+          },
+          stripe_options
+        )
       rescue ::Stripe::StripeError => e
         raise Pay::Stripe::Error, e
       end
 
       def swap(plan)
-        subscription = processor_subscription
-        subscription.cancel_at_period_end = false
-        subscription.plan = plan
-        subscription.proration_behavior = (prorate ? "create_prorations" : "none")
-        subscription.trial_end = on_trial? ? trial_ends_at.to_i : "now"
-        subscription.quantity = quantity if quantity?
-        subscription.save
+        raise ArgumentError, "plan must be a string" unless plan.is_a?(String)
+
+        ::Stripe::Subscription.update(
+          processor_id,
+          {
+            cancel_at_period_end: false,
+            plan: plan,
+            proration_behavior: (prorate ? "create_prorations" : "none"),
+            trial_end: (on_trial? ? trial_ends_at.to_i : "now"),
+            quantity: quantity
+          },
+          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

@@ -0,0 +1,16 @@
+module Pay
+  module Stripe
+    module Webhooks
+      class AccountUpdated
+        def call(event)
+          object = event.data.object
+
+          merchant = Pay::Merchant.find_by(processor: :stripe, processor_id: object.id)
+          return unless merchant
+
+          merchant.update(onboarding_complete: object.charges_enabled)
+        end
+      end
+    end
+  end
+end

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

@@ -3,13 +3,8 @@ module Pay
     module Webhooks
       class ChargeRefunded
         def call(event)
-          object = event.data.object
-          charge = Pay.charge_model.find_by(processor: :stripe, processor_id: object.id)
-
-          return unless charge.present?
-
-          charge.update(amount_refunded: object.amount_refunded)
-          notify_user(charge.owner, charge)
+          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
 
         def notify_user(billable, charge)

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

@@ -3,14 +3,8 @@ module Pay
     module Webhooks
       class ChargeSucceeded
         def call(event)
-          object = event.data.object
-          billable = Pay.find_billable(processor: :stripe, processor_id: object.customer)
-
-          return unless billable.present?
-          return if billable.charges.where(processor_id: object.id).any?
-
-          charge = Pay::Stripe::Billable.new(billable).save_pay_charge(object)
-          notify_user(billable, 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

@@ -0,0 +1,15 @@
+module Pay
+  module Stripe
+    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, stripe_account: event.try(:account))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module Pay
+  module Stripe
+    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, stripe_account: event.try(:account))
+          end
+        end
+      end
+    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