pay 2.6.10 → 2.7.2

data/lib/pay/stripe/charge.rb

@@ -3,24 +3,82 @@ module Pay
     class Charge
       attr_reader :pay_charge
 
-      delegate :processor_id, :owner, to: :pay_charge
+      delegate :processor_id, :owner, :stripe_account, to: :pay_charge
+
+      def self.sync(charge_id, object: 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)
+
+        owner = Pay.find_billable(processor: :stripe, processor_id: object.customer)
+        return unless owner
+
+        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
+        }
+
+        # 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)
+        end
+
+        # Update or create the charge
+        processor_details = {processor: :stripe, processor_id: object.id}
+        if (pay_charge = owner.charges.find_by(processor_details))
+          pay_charge.with_lock do
+            pay_charge.update!(attrs)
+          end
+          pay_charge
+        else
+          owner.charges.create!(attrs.merge(processor_details))
+        end
+      rescue ActiveRecord::RecordInvalid
+        try += 1
+        if try <= retries
+          sleep 0.1
+          retry
+        else
+          raise
+        end
+      end
 
       def initialize(pay_charge)
         @pay_charge = pay_charge
       end
 
       def charge
-        ::Stripe::Charge.retrieve(id: processor_id, expand: ["customer", "invoice.subscription"])
+        ::Stripe::Charge.retrieve({id: processor_id, expand: ["customer", "invoice.subscription"]}, stripe_options)
       rescue ::Stripe::StripeError => e
         raise Pay::Stripe::Error, e
       end
 
-      def refund!(amount_to_refund)
-        ::Stripe::Refund.create(charge: processor_id, amount: amount_to_refund)
+      # https://stripe.com/docs/api/refunds/create
+      #
+      # refund!
+      # 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_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

@@ -0,0 +1,66 @@
+module Pay
+  module Stripe
+    class Merchant
+      attr_reader :merchant
+
+      delegate :stripe_connect_account_id,
+        to: :merchant
+
+      def initialize(merchant)
+        @merchant = 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))
+        merchant.update(stripe_connect_account_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)
+      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,
+          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(stripe_connect_account_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: stripe_connect_account_id
+        }.merge(options))
+      rescue ::Stripe::StripeError => e
+        raise Pay::Stripe::Error, e
+      end
+    end
+  end
+end

data/lib/pay/stripe/subscription.rb

@@ -16,33 +16,82 @@ 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, 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"]})
+
+        owner = Pay.find_billable(processor: :stripe, processor_id: object.customer)
+        return unless owner
+
+        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)
+        }
+
+        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
+        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
+        else
+          owner.subscriptions.create!(attributes.merge(processor_details))
+        end
+      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 cancel
-        subscription = processor_subscription
-        subscription.cancel_at_period_end = true
-        subscription.save
+      def subscription(**options)
+        ::Stripe::Subscription.retrieve(options.merge(id: processor_id))
+      end
 
-        new_ends_at = on_trial? ? trial_ends_at : Time.at(subscription.current_period_end)
-        pay_subscription.update(ends_at: new_ends_at)
+      def cancel
+        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
@@ -64,26 +113,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,17 @@
+module Pay
+  module Stripe
+    module Webhooks
+      class AccountUpdated
+        def call(event)
+          object = event.data.object
+
+          merchant = Pay.find_merchant("stripe_connect_account_id", object.id)
+
+          return unless merchant.present?
+
+          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)
+          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)
+          notify_user(pay_charge.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,13 @@
+module Pay
+  module Stripe
+    module Webhooks
+      class CheckoutSessionAsyncPaymentSucceeded
+        def call(event)
+          if event.data.object.subscription
+            Pay::Stripe::Subscription.sync(event.data.object.subscription)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+module Pay
+  module Stripe
+    module Webhooks
+      class CheckoutSessionCompleted
+        def call(event)
+          if event.data.object.subscription
+            Pay::Stripe::Subscription.sync(event.data.object.subscription)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -4,15 +4,9 @@ module Pay
       class PaymentIntentSucceeded
         def call(event)
           object = event.data.object
-          billable = Pay.find_billable(processor: :stripe, processor_id: object.customer)
-
-          return unless billable.present?
-
           object.charges.data.each do |charge|
-            next if billable.charges.where(processor_id: charge.id).any?
-
-            charge = Pay::Stripe::Billable.new(billable).save_pay_charge(charge)
-            notify_user(billable, charge)
+            pay_charge = Pay::Stripe::Charge.sync(charge.id)
+            notify_user(pay_charge.owner, pay_charge) if pay_charge
           end
         end
 

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

@@ -0,0 +1,17 @@
+module Pay
+  module Stripe
+    module Webhooks
+      class PaymentMethodAttached
+        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)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module Pay
+  module Stripe
+    module Webhooks
+      class PaymentMethodAutomaticallyUpdated
+        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)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module Pay
+  module Stripe
+    module Webhooks
+      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)
+        end
+      end
+    end
+  end
+end