pay 2.7.0 → 3.0.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,36 +19,90 @@ module Pay
         :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
-        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?
@@ -72,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,
           {
@@ -88,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,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

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

@@ -2,23 +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
-          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)
-          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

@@ -0,0 +1,15 @@
+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)
+          return unless pay_customer
+
+          pay_customer.save_payment_method(object, default: false)
+        end
+      end
+    end
+  end
+end