pay 11.8.0 → 12.0.0

data/app/models/pay/paddle_classic/subscription.rb

@@ -1,52 +1,54 @@
 module Pay
   module PaddleClassic
     class Subscription < Pay::Subscription
+      extend Pay::Sync
+
       store_accessor :data, :paddle_update_url
       store_accessor :data, :paddle_cancel_url
 
       def self.sync(subscription_id, object: nil, name: Pay.default_product_name)
-        # Passthrough is not return from this API, so we can't use that
-        object ||= PaddleClassic.client.users.list(subscription_id: subscription_id).data.try(:first)
-
-        pay_customer = Pay::Customer.find_by(processor: :paddle_classic, processor_id: object.user_id)
-
-        # If passthrough exists (only on webhooks) we can use it to create the Pay::Customer
-        if pay_customer.nil? && object.passthrough
-          owner = Pay::PaddleClassic.owner_from_passthrough(object.passthrough)
-          pay_customer = owner&.set_payment_processor(:paddle_classic, processor_id: object.user_id)
-        end
+        sync_with_retries do
+          subscription = object || PaddleClassic.client.users.list(subscription_id: subscription_id).data.first
+          pay_customer = find_pay_customer(subscription.user_id)
+
+          # If passthrough exists (only on webhooks) we can use it to create the Pay::Customer
+          if pay_customer.nil? && subscription.passthrough
+            owner = Pay::PaddleClassic.owner_from_passthrough(subscription.passthrough)
+            pay_customer = owner&.set_payment_processor(:paddle_classic, processor_id: subscription.user_id)
+          end
 
-        return unless pay_customer
-
-        attributes = {
-          paddle_cancel_url: object.cancel_url,
-          paddle_update_url: object.update_url,
-          processor_plan: object.plan_id || object.subscription_plan_id,
-          quantity: object.quantity || 1,
-          status: object.state || object.status
-        }
-
-        case attributes[:status]
-        when "trialing"
-          attributes[:trial_ends_at] = Time.zone.parse(object.next_bill_date)
-          attributes[:ends_at] = nil
-        when "active", "past_due"
-          attributes[:trial_ends_at] = nil
-          attributes[:ends_at] = nil
-        when "paused", "deleted"
-          # If paused or delete while on trial, set ends_at to match
-          attributes[:trial_ends_at] = nil
-          attributes[:ends_at] = Time.zone.parse(object.next_bill_date)
-        end
+          return unless pay_customer
+
+          attributes = {
+            paddle_cancel_url: subscription.cancel_url,
+            paddle_update_url: subscription.update_url,
+            processor_plan: subscription.plan_id || subscription.subscription_plan_id,
+            quantity: subscription.quantity || 1,
+            status: subscription.state || subscription.status
+          }
+
+          case attributes[:status]
+          when "trialing"
+            attributes[:trial_ends_at] = Time.zone.parse(subscription.next_bill_date)
+            attributes[:ends_at] = nil
+          when "active", "past_due"
+            attributes[:trial_ends_at] = nil
+            attributes[:ends_at] = nil
+          when "paused", "deleted"
+            # If paused or delete while on trial, set ends_at to match
+            attributes[:trial_ends_at] = nil
+            attributes[:ends_at] = Time.zone.parse(subscription.next_bill_date)
+          end
 
-        # Update or create the subscription
-        if (pay_subscription = pay_customer.subscriptions.find_by(processor_id: object.subscription_id))
-          pay_subscription.with_lock do
-            pay_subscription.update!(attributes)
+          # Update or create the subscription
+          if (pay_subscription = pay_customer.subscriptions.find_by(processor_id: subscription.subscription_id))
+            pay_subscription.with_lock do
+              pay_subscription.update!(attributes)
+            end
+            pay_subscription
+          else
+            pay_customer.subscriptions.create!(attributes.merge(name: name, processor_id: subscription.subscription_id))
           end
-          pay_subscription
-        else
-          pay_customer.subscriptions.create!(attributes.merge(name: name, processor_id: object.subscription_id))
         end
       end
 
@@ -93,7 +95,7 @@ module Pay
       end
 
       def change_quantity(quantity, **options)
-        raise NotImplementedError, "Paddle does not support setting quantity on subscriptions"
+        raise Pay::NotSupportedError, "Paddle does not support setting quantity on subscriptions"
       end
 
       # A subscription could be set to cancel or pause in the future
@@ -139,10 +141,6 @@ module Pay
       rescue ::Paddle::Error => e
         raise Pay::PaddleClassic::Error, e
       end
-
-      # Retries the latest invoice for a Past Due subscription
-      def retry_failed_payment
-      end
     end
   end
 end

data/app/models/pay/payment_method.rb

@@ -12,15 +12,11 @@ module Pay
     store_accessor :data, :username
     store_accessor :data, :bank
 
-    validates :processor_id, presence: true, uniqueness: {scope: :customer_id, case_sensitive: true}
+    validates :processor_id, presence: true
 
     def self.find_by_processor_and_id(processor, processor_id)
       joins(:customer).find_by(processor_id: processor_id, pay_customers: {processor: processor})
     end
-
-    def self.pay_processor_for(name)
-      "Pay::#{name.to_s.classify}::PaymentMethod".constantize
-    end
   end
 end
 

data/app/models/pay/stripe/charge.rb

@@ -1,6 +1,8 @@
 module Pay
   module Stripe
     class Charge < Pay::Charge
+      extend Pay::Sync
+
       EXPAND = ["balance_transaction", "payment_intent", "refunds.data.balance_transaction"]
 
       delegate :amount_captured, :payment_intent, to: :stripe_object, allow_nil: true
@@ -11,73 +13,59 @@ module Pay
       def self.sync_payment_intent(id, stripe_account: nil)
         payment_intent = ::Stripe::PaymentIntent.retrieve({id: id}, {stripe_account: stripe_account}.compact)
         sync(payment_intent.latest_charge, stripe_account: stripe_account)
+      rescue ::Stripe::StripeError => e
+        raise Pay::Stripe::Error, e
       end
 
-      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({id: charge_id, expand: EXPAND}, {stripe_account: stripe_account}.compact)
-        if object.customer.blank?
-          Rails.logger.debug "Stripe Charge #{object.id} does not have a customer"
-          return
-        end
-
-        pay_customer = Pay::Customer.find_by(processor: :stripe, processor_id: object.customer)
-        if pay_customer.blank?
-          Rails.logger.debug "Pay::Customer #{object.customer} is not in the database while syncing Stripe Charge #{object.id}"
-          return
-        end
-
-        # Requests for the rest of the sync should go to the same Stripe Connect account as the customer
-        stripe_account ||= pay_customer.stripe_account
-
-        payment_method = object.payment_method_details.try(object.payment_method_details.type)
-        attrs = {
-          object: object.to_hash,
-          amount: object.amount,
-          amount_refunded: object.amount_refunded,
-          application_fee_amount: object.application_fee_amount,
-          bank: payment_method.try(:bank_name) || payment_method.try(:bank), # eps, fpx, ideal, p24, acss_debit, etc
-          brand: payment_method.try(:brand)&.capitalize,
-          created_at: Time.at(object.created),
-          currency: object.currency,
-          exp_month: payment_method.try(:exp_month).to_s,
-          exp_year: payment_method.try(:exp_year).to_s,
-          last4: payment_method.try(:last4).to_s,
-          metadata: object.metadata,
-          payment_method_type: object.payment_method_details.type,
-          stripe_account: stripe_account,
-          stripe_receipt_url: object.receipt_url
-        }
-
-        # Associate charge with subscription if we can
-        if object.payment_intent.present?
-          invoice_payments = ::Stripe::InvoicePayment.list({payment: {type: :payment_intent, payment_intent: object.payment_intent}, status: :paid}, {stripe_account: stripe_account}.compact)
-          if invoice_payments.any?
-            invoice = ::Stripe::Invoice.retrieve({id: invoice_payments.first.invoice, expand: ["total_discount_amounts.discount.source.coupon"]}, {stripe_account: stripe_account}.compact)
-            attrs[:stripe_invoice] = invoice.to_hash
-            attrs[:subtotal] = invoice.subtotal
-            attrs[:tax] = invoice.total - invoice.total_excluding_tax.to_i
-            if (subscription = invoice.parent.try(:subscription_details).try(:subscription))
-              attrs[:subscription] = pay_customer.subscriptions.find_by(processor_id: subscription)
+      def self.sync(charge_id, object: nil, stripe_account: nil, retries: 1)
+        sync_with_retries(retries: retries) do
+          charge = object || ::Stripe::Charge.retrieve({id: charge_id, expand: EXPAND}, {stripe_account: stripe_account}.compact)
+          return unless (pay_customer = find_pay_customer(charge.customer))
+          stripe_account ||= pay_customer.stripe_account
+
+          payment_method = charge.payment_method_details.try(charge.payment_method_details.type)
+          attrs = {
+            object: charge.to_hash,
+            amount: charge.amount,
+            amount_refunded: charge.amount_refunded,
+            application_fee_amount: charge.application_fee_amount,
+            bank: payment_method.try(:bank_name) || payment_method.try(:bank), # eps, fpx, ideal, p24, acss_debit, etc
+            brand: payment_method.try(:brand)&.capitalize,
+            created_at: Time.at(charge.created),
+            currency: charge.currency,
+            exp_month: payment_method.try(:exp_month).to_s,
+            exp_year: payment_method.try(:exp_year).to_s,
+            last4: payment_method.try(:last4).to_s,
+            metadata: charge.metadata,
+            payment_method_type: charge.payment_method_details.type,
+            stripe_account: stripe_account,
+            stripe_receipt_url: charge.receipt_url
+          }
+
+          # Associate charge with subscription if we can
+          if charge.payment_intent.present?
+            invoice_payments = ::Stripe::InvoicePayment.list({payment: {type: :payment_intent, payment_intent: charge.payment_intent}, status: :paid}, {stripe_account: stripe_account}.compact)
+            if invoice_payments.any?
+              invoice = ::Stripe::Invoice.retrieve({id: invoice_payments.first.invoice, expand: ["total_discount_amounts.discount.source.coupon"]}, {stripe_account: stripe_account}.compact)
+              attrs[:stripe_invoice] = invoice.to_hash
+              attrs[:subtotal] = invoice.subtotal
+              attrs[:tax] = invoice.total - invoice.total_excluding_tax.to_i
+              if (subscription = invoice.parent.try(:subscription_details).try(:subscription))
+                attrs[:subscription] = pay_customer.subscriptions.find_by(processor_id: subscription)
+              end
             end
           end
-        end
 
-        # Update or create the charge
-        if (pay_charge = find_by(customer: pay_customer, processor_id: object.id))
-          pay_charge.with_lock { pay_charge.update!(attrs) }
-          pay_charge
-        else
-          create!(attrs.merge(customer: pay_customer, processor_id: object.id))
-        end
-      rescue ActiveRecord::RecordInvalid, ActiveRecord::RecordNotUnique
-        if try > retries
-          raise
-        else
-          try += 1
-          sleep 0.15 * try
-          retry
+          # Update or create the charge
+          if (pay_charge = find_by(customer: pay_customer, processor_id: charge.id))
+            pay_charge.with_lock { pay_charge.update!(attrs) }
+            pay_charge
+          else
+            create!(attrs.merge(customer: pay_customer, processor_id: charge.id))
+          end
         end
+      rescue ::Stripe::StripeError => e
+        raise Pay::Stripe::Error, e
       end
 
       def api_record

data/app/models/pay/stripe/customer.rb

@@ -38,8 +38,9 @@ module Pay
       end
 
       def update_api_record(**attributes)
-        api_record unless processor_id?
-        ::Stripe::Customer.update(processor_id, api_record_attributes.merge(attributes), stripe_options)
+        ::Stripe::Customer.update(stripe_customer_id, api_record_attributes.merge(attributes), stripe_options)
+      rescue ::Stripe::StripeError => e
+        raise Pay::Stripe::Error, e
       end
 
       # Charges an amount to the customer's default payment method
@@ -62,7 +63,7 @@ module Pay
         }.merge(options)
 
         # Load the Stripe customer to verify it exists and update payment method if needed
-        opts[:customer] = processor_id || api_record.id
+        opts[:customer] = stripe_customer_id
 
         # Create subscription on Stripe
         stripe_sub = ::Stripe::Subscription.create(opts.merge(Pay::Stripe::Subscription.expand_options), stripe_options)
@@ -82,11 +83,10 @@ module Pay
       end
 
       def add_payment_method(payment_method_id, default: false)
-        api_record unless processor_id?
-        payment_method = ::Stripe::PaymentMethod.attach(payment_method_id, {customer: processor_id}, stripe_options)
+        payment_method = ::Stripe::PaymentMethod.attach(payment_method_id, {customer: stripe_customer_id}, stripe_options)
 
         if default
-          ::Stripe::Customer.update(processor_id, {
+          ::Stripe::Customer.update(stripe_customer_id, {
             invoice_settings: {
               default_payment_method: payment_method.id
             }
@@ -121,12 +121,14 @@ module Pay
         args = {
           amount: amount,
           currency: "usd",
-          customer: processor_id || api_record.id,
+          customer: stripe_customer_id,
           expand: Pay::Stripe::Charge::EXPAND.map { |option| "latest_charge.#{option}" },
           return_url: root_url
         }.merge(options)
 
         ::Stripe::PaymentIntent.create(args, stripe_options)
+      rescue ::Stripe::StripeError => e
+        raise Pay::Stripe::Error, e
       end
 
       # Used for creating Stripe Terminal charges
@@ -135,15 +137,21 @@ module Pay
       end
 
       def create_setup_intent(options = {})
-        ::Stripe::SetupIntent.create({customer: processor_id || api_record.id, usage: :off_session}.merge(options), stripe_options)
+        ::Stripe::SetupIntent.create({customer: stripe_customer_id, usage: :off_session}.merge(options), stripe_options)
+      rescue ::Stripe::StripeError => e
+        raise Pay::Stripe::Error, e
       end
 
       def invoice!(options = {})
-        ::Stripe::Invoice.create(options.merge(customer: processor_id || api_record.id), stripe_options).pay
+        ::Stripe::Invoice.create(options.merge(customer: stripe_customer_id), stripe_options).pay
+      rescue ::Stripe::StripeError => e
+        raise Pay::Stripe::Error, e
       end
 
       def preview_invoice(**options)
-        ::Stripe::Invoice.create_preview(options.merge(customer: processor_id || api_record.id), stripe_options)
+        ::Stripe::Invoice.create_preview(options.merge(customer: stripe_customer_id), stripe_options)
+      rescue ::Stripe::StripeError => e
+        raise Pay::Stripe::Error, e
       end
 
       # Syncs a customer's subscriptions from Stripe to the database.
@@ -168,9 +176,8 @@ module Pay
       # checkout(line_items: "price_12345", allow_promotion_codes: true)
       #
       def checkout(**options)
-        api_record unless processor_id?
         args = {
-          customer: processor_id,
+          customer: stripe_customer_id,
           mode: "payment"
         }
 
@@ -201,6 +208,8 @@ module Pay
         end
 
         ::Stripe::Checkout::Session.create(args.merge(options), stripe_options)
+      rescue ::Stripe::StripeError => e
+        raise Pay::Stripe::Error, e
       end
 
       # https://stripe.com/docs/api/checkout/sessions/create
@@ -208,7 +217,6 @@ module Pay
       # checkout_charge(amount: 15_00, name: "T-shirt", quantity: 2)
       #
       def checkout_charge(amount:, name:, quantity: 1, **options)
-        api_record unless processor_id?
         currency = options.delete(:currency) || "usd"
         checkout(
           line_items: {
@@ -224,38 +232,52 @@ module Pay
       end
 
       def billing_portal(**options)
-        api_record unless processor_id?
         args = {
-          customer: processor_id,
+          customer: stripe_customer_id,
           return_url: options.delete(:return_url) || root_url
         }
         ::Stripe::BillingPortal::Session.create(args.merge(options), stripe_options)
+      rescue ::Stripe::StripeError => e
+        raise Pay::Stripe::Error, e
       end
 
       def customer_session(**options)
-        api_record unless processor_id?
-        args = {customer: processor_id}
+        args = {customer: stripe_customer_id}
         ::Stripe::CustomerSession.create(args.merge(options), stripe_options)
+      rescue ::Stripe::StripeError => e
+        raise Pay::Stripe::Error, e
       end
 
       def authorize(amount, options = {})
         charge(amount, options.merge(capture_method: :manual))
       end
 
+      # Attempts to pay all past_due subscription invoices to bring them back to active state
+      # Pass in `status: []` to include other subscription statuses
+      def retry_past_due_subscriptions!(status: [:past_due])
+        subscriptions.where(status: Array.wrap(status)).each(&:pay_open_invoices)
+      end
+
       # Creates a meter event to bill for usage
       #
       # create_meter_event(:api_request, value: 1)
       # create_meter_event(:api_request, token: 7)
       def create_meter_event(event_name, payload: {}, **options)
-        api_record unless processor_id?
         ::Stripe::Billing::MeterEvent.create({
           event_name: event_name,
-          payload: {stripe_customer_id: processor_id}.merge(payload)
+          payload: {stripe_customer_id: stripe_customer_id}.merge(payload)
         }.merge(options), stripe_options)
+      rescue ::Stripe::StripeError => e
+        raise Pay::Stripe::Error, e
       end
 
       private
 
+      # The Stripe::Customer ID, creating the customer on Stripe first if this record doesn't have one yet
+      def stripe_customer_id
+        processor_id || api_record.id
+      end
+
       # Options for Stripe requests
       def stripe_options
         {stripe_account: stripe_account}.compact

data/app/models/pay/stripe/payment_method.rb

@@ -1,12 +1,16 @@
 module Pay
   module Stripe
     class PaymentMethod < Pay::PaymentMethod
+      extend Pay::Sync
+
       # Syncs a PaymentIntent's payment method to the database
       def self.sync_payment_intent(id, stripe_account: nil)
         payment_intent = ::Stripe::PaymentIntent.retrieve({id: id, expand: ["payment_method"]}, {stripe_account: stripe_account}.compact)
         payment_method = payment_intent.payment_method
         return unless payment_method
         Pay::Stripe::PaymentMethod.sync(payment_method.id, object: payment_method, stripe_account: stripe_account)
+      rescue ::Stripe::StripeError => e
+        raise Pay::Stripe::Error, e
       end
 
       # Syncs a SetupIntent's payment method to the database
@@ -15,42 +19,29 @@ module Pay
         payment_method = setup_intent.payment_method
         return unless payment_method
         Pay::Stripe::PaymentMethod.sync(payment_method.id, object: payment_method, stripe_account: stripe_account)
+      rescue ::Stripe::StripeError => e
+        raise Pay::Stripe::Error, e
       end
 
       # Syncs PaymentMethod objects from Stripe
-      def self.sync(id, object: nil, stripe_account: nil, try: 0, retries: 1)
-        object ||= ::Stripe::PaymentMethod.retrieve(id, {stripe_account: stripe_account}.compact)
-        if object.customer.blank?
-          Rails.logger.debug "Stripe PaymentMethod #{object.id} does not have a customer"
-          return
-        end
-
-        pay_customer = Pay::Customer.find_by(processor: :stripe, processor_id: object.customer)
-        if pay_customer.blank?
-          Rails.logger.debug "Pay::Customer #{object.customer} is not in the database while syncing Stripe PaymentMethod #{object.id}"
-          return
-        end
-
-        # Record the same Stripe Connect account as the customer when one wasn't given
-        stripe_account ||= pay_customer.stripe_account
+      def self.sync(id, object: nil, stripe_account: nil, retries: 1)
+        sync_with_retries(retries: retries) do
+          payment_method = object || ::Stripe::PaymentMethod.retrieve(id, {stripe_account: stripe_account}.compact)
+          return unless (pay_customer = find_pay_customer(payment_method.customer))
+          stripe_account ||= pay_customer.stripe_account
 
-        default_payment_method_id = pay_customer.api_record.invoice_settings&.default_payment_method
-        default = (id == default_payment_method_id)
+          default_payment_method_id = pay_customer.api_record.invoice_settings&.default_payment_method
+          default = (id == default_payment_method_id)
 
-        attributes = extract_attributes(object).merge(default: default, stripe_account: stripe_account)
+          attributes = extract_attributes(payment_method).merge(default: default, stripe_account: stripe_account)
 
-        where(customer: pay_customer).update_all(default: false) if default
-        pay_payment_method = where(customer: pay_customer, processor_id: object.id).first_or_initialize
-        pay_payment_method.update!(attributes)
-        pay_payment_method
-      rescue ActiveRecord::RecordInvalid, ActiveRecord::RecordNotUnique
-        if try > retries
-          raise
-        else
-          try += 1
-          sleep 0.15 * try
-          retry
+          where(customer: pay_customer).update_all(default: false) if default
+          pay_payment_method = where(customer: pay_customer, processor_id: payment_method.id).first_or_initialize
+          pay_payment_method.update!(attributes)
+          pay_payment_method
         end
+      rescue ::Stripe::StripeError => e
+        raise Pay::Stripe::Error, e
       end
 
       # Extracts payment method details from a Stripe::PaymentMethod object
@@ -76,11 +67,15 @@ module Pay
 
         customer.payment_methods.update_all(default: false)
         update!(default: true)
+      rescue ::Stripe::StripeError => e
+        raise Pay::Stripe::Error, e
       end
 
       # Remove payment method
       def detach
-        ::Stripe::PaymentMethod.detach(processor_id, stripe_options)
+        ::Stripe::PaymentMethod.detach(processor_id, {}, stripe_options)
+      rescue ::Stripe::StripeError => e
+        raise Pay::Stripe::Error, e
       end
 
       private