pay 2.6.8 → 2.7.1

data/lib/pay/stripe/charge.rb

@@ -3,20 +3,54 @@ 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)
+        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
+
+        pay_charge = owner.charges.find_or_initialize_by(processor: :stripe, processor_id: object.id)
+        pay_charge.update(attrs)
+        pay_charge
+      end
 
       def initialize(pay_charge)
         @pay_charge = pay_charge
       end
 
       def charge
-        ::Stripe::Charge.retrieve(processor_id)
+        ::Stripe::Charge.retrieve({id: processor_id, expand: ["customer", "invoice.subscription"]}, {stripe_account: stripe_account})
       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_account: stripe_account})
         pay_charge.update(amount_refunded: amount_to_refund)
       rescue ::Stripe::StripeError => e
         raise Pay::Stripe::Error, e

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,27 +16,63 @@ 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)
+        # 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)
+        }
+
+        # 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
+
+        # 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
+      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_account: stripe_account})
+        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_account: stripe_account})
+        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)
       rescue ::Stripe::StripeError => e
         raise Pay::Stripe::Error, e
       end
@@ -58,23 +94,31 @@ 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_account: stripe_account}
+        )
       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
+        ::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_account: stripe_account}
+        )
       rescue ::Stripe::StripeError => e
         raise Pay::Stripe::Error, e
       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/subscription_created.rb

@@ -3,41 +3,7 @@ module Pay
     module Webhooks
       class SubscriptionCreated
         def call(event)
-          object = event.data.object
-
-          # We may already have the subscription in the database, so we can update that record
-          subscription = Pay.subscription_model.find_by(processor: :stripe, processor_id: object.id)
-
-          # Create the subscription in the database if we don't have it already
-          if subscription.nil?
-            # The customer should already be in the database
-            owner = Pay.find_billable(processor: :stripe, processor_id: object.customer)
-
-            if owner.nil?
-              Rails.logger.error("[Pay] Unable to find Pay::Billable with processor: :stripe and processor_id: '#{object.customer}'. Searched these models: #{Pay.billable_models.join(", ")}")
-              return
-            end
-
-            subscription = Pay.subscription_model.new(name: Pay.default_product_name, owner: owner, processor: :stripe, processor_id: object.id)
-          end
-
-          subscription.quantity = object.quantity
-          subscription.status = object.status
-          subscription.processor_plan = object.plan.id
-          subscription.trial_ends_at = Time.at(object.trial_end) if object.trial_end.present?
-
-          # If user was on trial, their subscription ends at the end of the trial
-          subscription.ends_at = if object.cancel_at_period_end && subscription.on_trial?
-            subscription.trial_ends_at
-
-          # User wasn't on trial, so subscription ends at period end
-          elsif object.cancel_at_period_end
-            Time.at(object.current_period_end)
-
-            # Subscription isn't marked to cancel at period end
-          end
-
-          subscription.save!
+          Pay::Stripe::Subscription.sync(event.data.object.id)
         end
       end
     end

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

@@ -3,15 +3,7 @@ module Pay
     module Webhooks
       class SubscriptionDeleted
         def call(event)
-          object = event.data.object
-          subscription = Pay.subscription_model.find_by(processor: :stripe, processor_id: object.id)
-
-          # We couldn't find the subscription for some reason, maybe it's from another service
-          return if subscription.nil?
-
-          # User canceled subscriptions have an ends_at
-          # Automatically canceled subscriptions need this value set
-          subscription.update!(ends_at: Time.at(object.ended_at)) if subscription.ends_at.blank? && object.ended_at.present?
+          Pay::Stripe::Subscription.sync(event.data.object.id)
         end
       end
     end

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

@@ -5,12 +5,10 @@ module Pay
         def call(event)
           # Event is of type "invoice" see:
           # https://stripe.com/docs/api/invoices/object
-          subscription = Pay.subscription_model.find_by(
-            processor: :stripe,
-            processor_id: event.data.object.subscription
-          )
-          date = Time.zone.at(event.data.object.next_payment_attempt)
-          notify_user(subscription.owner, subscription, date) if subscription.present?
+          subscription = Pay.subscription_model.find_by(processor: :stripe, processor_id: event.data.object.subscription)
+          return unless subscription
+
+          notify_user(subscription.owner, subscription, Time.zone.at(event.data.object.next_payment_attempt))
         end
 
         def notify_user(billable, subscription, date)

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

@@ -3,34 +3,7 @@ module Pay
     module Webhooks
       class SubscriptionUpdated
         def call(event)
-          object = event.data.object
-          subscription = Pay.subscription_model.find_by(processor: :stripe, processor_id: object.id)
-
-          return if subscription.nil?
-
-          # Delete any subscription attempts that have expired
-          if object.status == "incomplete_expired"
-            subscription.destroy
-            return
-          end
-
-          subscription.status = object.status
-          subscription.quantity = object.quantity
-          subscription.processor_plan = object.plan.id
-          subscription.trial_ends_at = Time.at(object.trial_end) if object.trial_end.present?
-
-          # If user was on trial, their subscription ends at the end of the trial
-          subscription.ends_at = if object.cancel_at_period_end && subscription.on_trial?
-            subscription.trial_ends_at
-
-          # User wasn't on trial, so subscription ends at period end
-          elsif object.cancel_at_period_end
-            Time.at(object.current_period_end)
-
-            # Subscription isn't marked to cancel at period end
-          end
-
-          subscription.save!
+          Pay::Stripe::Subscription.sync(event.data.object.id)
         end
       end
     end