pay 11.7.2 → 12.0.0

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

@@ -1,127 +1,116 @@
 module Pay
   module Stripe
     class Subscription < Pay::Subscription
+      extend Pay::Sync
+
       attr_writer :api_record
 
       def self.sync_from_checkout_session(session_id, stripe_account: nil)
-        checkout_session = ::Stripe::Checkout::Session.retrieve({id: session_id}, {stripe_account: stripe_account}.compact)
-        sync(checkout_session.subscription)
+        Pay.deprecator.warn "Pay::Stripe::Subscription.sync_from_checkout_session is deprecated, use Pay::Stripe.sync_checkout_session instead"
+        Pay::Stripe.sync_checkout_session(session_id, stripe_account: stripe_account)
       end
 
-      def self.sync(subscription_id, object: nil, name: nil, 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}.merge(expand_options), {stripe_account: stripe_account}.compact)
-        if object.customer.blank?
-          Rails.logger.debug "Stripe Subscription #{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 Subscription #{object.id}"
-          return
-        end
-
-        attributes = {
-          object: object.to_hash,
-          application_fee_percent: object.application_fee_percent,
-          created_at: Time.at(object.created),
-          processor_plan: object.items.first.price.id,
-          quantity: object.items.first.try(:quantity) || 0,
-          status: object.status,
-          stripe_account: pay_customer.stripe_account,
-          metadata: object.metadata,
-          metered: false,
-          pause_behavior: object.pause_collection&.behavior,
-          pause_resumes_at: (object.pause_collection&.resumes_at ? Time.at(object.pause_collection&.resumes_at) : nil),
-          current_period_start: (object.items.first.current_period_start ? Time.at(object.items.first.current_period_start) : nil),
-          current_period_end: (object.items.first.current_period_end ? Time.at(object.items.first.current_period_end) : nil)
-        }
-
-        # Subscriptions that have ended should have their trial ended at the
-        # same time if they were still on trial (if you cancel a
-        # subscription, your are cancelling your trial as well at the same
-        # instant). This avoids canceled subscriptions responding `true`
-        # to #on_trial? due to the `trial_ends_at` being left set in the
-        # future.
-        if object.trial_end
-          trial_ended_at = [object.ended_at, object.trial_end].compact.min
-          attributes[:trial_ends_at] = Time.at(trial_ended_at)
-        else
-          attributes[:trial_ends_at] = nil
-        end
-
-        object.items.auto_paging_each do |subscription_item|
-          next if attributes[:metered]
-          attributes[:metered] = true if subscription_item.price.try(:recurring).try(:usage_type) == "metered"
-        end
+      def self.sync(subscription_id, object: nil, name: nil, stripe_account: nil, retries: 1)
+        sync_with_retries(retries: retries) do
+          subscription = object || ::Stripe::Subscription.retrieve({id: subscription_id}.merge(expand_options), {stripe_account: stripe_account}.compact)
+          return unless (pay_customer = find_pay_customer(subscription.customer))
+          stripe_account ||= pay_customer.stripe_account
+
+          attributes = {
+            object: subscription.to_hash,
+            application_fee_percent: subscription.application_fee_percent,
+            created_at: Time.at(subscription.created),
+            processor_plan: subscription.items.first.price.id,
+            quantity: subscription.items.first.try(:quantity) || 0,
+            status: subscription.status,
+            stripe_account: stripe_account,
+            metadata: subscription.metadata,
+            metered: false,
+            pause_behavior: subscription.pause_collection&.behavior,
+            pause_resumes_at: (subscription.pause_collection&.resumes_at ? Time.at(subscription.pause_collection&.resumes_at) : nil),
+            current_period_start: (subscription.items.first.current_period_start ? Time.at(subscription.items.first.current_period_start) : nil),
+            current_period_end: (subscription.items.first.current_period_end ? Time.at(subscription.items.first.current_period_end) : nil)
+          }
+
+          # Subscriptions that have ended should have their trial ended at the
+          # same time if they were still on trial (if you cancel a
+          # subscription, your are cancelling your trial as well at the same
+          # instant). This avoids canceled subscriptions responding `true`
+          # to #on_trial? due to the `trial_ends_at` being left set in the
+          # future.
+          if subscription.trial_end
+            trial_ended_at = [subscription.ended_at, subscription.trial_end].compact.min
+            attributes[:trial_ends_at] = Time.at(trial_ended_at)
+          else
+            attributes[:trial_ends_at] = nil
+          end
 
-        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.items.first.current_period_end)
-        end
+          subscription.items.auto_paging_each do |subscription_item|
+            next if attributes[:metered]
+            attributes[:metered] = true if subscription_item.price.try(:recurring).try(:usage_type) == "metered"
+          end
 
-        # Sync payment method if directly attached to subscription
-        if object.default_payment_method
-          if object.default_payment_method.is_a? String
-            Pay::Stripe::PaymentMethod.sync(object.default_payment_method)
-            attributes[:payment_method_id] = object.default_payment_method
-          else
-            Pay::Stripe::PaymentMethod.sync(object.default_payment_method.id, object: object.default_payment_method)
-            attributes[:payment_method_id] = object.default_payment_method.id
+          attributes[:ends_at] = if subscription.ended_at
+            # Fully cancelled subscription
+            Time.at(subscription.ended_at)
+          elsif subscription.cancel_at
+            # subscription cancelling in the future
+            Time.at(subscription.cancel_at)
+          elsif subscription.cancel_at_period_end
+            # Subscriptions cancelling in the future
+            Time.at(subscription.items.first.current_period_end)
           end
-        end
 
-        # Update or create the subscription
-        pay_subscription = find_by(customer: pay_customer, processor_id: object.id)
-        if pay_subscription
-          # If pause behavior is changing to `void`, record the pause start date
-          # Any other pause status (or no pause at all) should have nil for start
-          if pay_subscription.pause_behavior != attributes[:pause_behavior]
-            attributes[:pause_starts_at] = if attributes[:pause_behavior] == "void"
-              Time.at(object.items.first.current_period_end)
+          # Sync payment method if directly attached to subscription
+          if subscription.default_payment_method
+            if subscription.default_payment_method.is_a? String
+              Pay::Stripe::PaymentMethod.sync(subscription.default_payment_method, stripe_account: stripe_account)
+              attributes[:payment_method_id] = subscription.default_payment_method
+            else
+              Pay::Stripe::PaymentMethod.sync(subscription.default_payment_method.id, object: subscription.default_payment_method, stripe_account: stripe_account)
+              attributes[:payment_method_id] = subscription.default_payment_method.id
             end
           end
 
-          pay_subscription.with_lock { pay_subscription.update!(attributes) }
-        else
-          # Allow setting the subscription name in metadata, otherwise use the default
-          name ||= object.metadata["pay_name"] || Pay.default_product_name
-          pay_subscription = create!(attributes.merge(customer: pay_customer, name: name, processor_id: object.id))
-        end
+          # Update or create the subscription
+          pay_subscription = find_by(customer: pay_customer, processor_id: subscription.id)
+          if pay_subscription
+            # If pause behavior is changing to `void`, record the pause start date
+            # Any other pause status (or no pause at all) should have nil for start
+            if pay_subscription.pause_behavior != attributes[:pause_behavior]
+              attributes[:pause_starts_at] = if attributes[:pause_behavior] == "void"
+                Time.at(subscription.items.first.current_period_end)
+              end
+            end
+
+            pay_subscription.with_lock { pay_subscription.update!(attributes) }
+          else
+            # Allow setting the subscription name in metadata, otherwise use the default
+            name ||= subscription.metadata["pay_name"] || Pay.default_product_name
+            pay_subscription = create!(attributes.merge(customer: pay_customer, name: name, processor_id: subscription.id))
+          end
 
-        # Cache the Stripe subscription on the Pay::Subscription that we return
-        pay_subscription.api_record = object
+          # Cache the Stripe subscription on the Pay::Subscription that we return
+          pay_subscription.api_record = subscription
 
-        # Sync the latest charge if we already have it loaded (like during subscrbe), otherwise, let webhooks take care of creating it
-        if (invoice = object.try(:latest_invoice))
-          Array(invoice.try(:payments)).each do |invoice_payment|
-            next unless invoice_payment.status == "paid"
+          # Sync the latest charge if we already have it loaded (like during subscrbe), otherwise, let webhooks take care of creating it
+          if (invoice = subscription.try(:latest_invoice))
+            Array(invoice.try(:payments)).each do |invoice_payment|
+              next unless invoice_payment.status == "paid"
 
-            case invoice_payment.payment.type
-            when "payment_intent"
-              Pay::Stripe::Charge.sync_payment_intent(invoice_payment.payment.payment_intent, stripe_account: pay_subscription.stripe_account)
-            when "charge"
-              Pay::Stripe::Charge.sync(invoice_payment.payment.charge, stripe_account: pay_subscription.stripe_account)
+              case invoice_payment.payment.type
+              when "payment_intent"
+                Pay::Stripe::Charge.sync_payment_intent(invoice_payment.payment.payment_intent, stripe_account: stripe_account)
+              when "charge"
+                Pay::Stripe::Charge.sync(invoice_payment.payment.charge, stripe_account: stripe_account)
+              end
             end
           end
-        end
 
-        pay_subscription
-      rescue ActiveRecord::RecordInvalid, ActiveRecord::RecordNotUnique
-        try += 1
-        if try <= retries
-          sleep 0.1
-          retry
-        else
-          raise
+          pay_subscription
         end
+      rescue ::Stripe::StripeError => e
+        raise Pay::Stripe::Error, e
       end
 
       # Common expand options for all requests that create, retrieve, or update a Stripe Subscription
@@ -144,8 +133,14 @@ module Pay
         ::Stripe::Subscription.construct_from(object)
       end
 
+      def sync!(**options)
+        super(**options.with_defaults(stripe_account: stripe_account))
+      end
+
       def api_record(**options)
         @api_record ||= ::Stripe::Subscription.retrieve(options.with_defaults(id: processor_id).merge(expand_options), {stripe_account: stripe_account}.compact)
+      rescue ::Stripe::StripeError => e
+        raise Pay::Stripe::Error, e
       end
 
       # Returns a SetupIntent or PaymentIntent client secret for the subscription
@@ -198,16 +193,12 @@ module Pay
 
       # This updates a SubscriptionItem's quantity in Stripe
       #
-      # For a subscription with a single item, we can update the subscription directly if no SubscriptionItem ID is available
-      # Otherwise a SubscriptionItem ID is required so Stripe knows which entry to update
+      # Defaults to the first SubscriptionItem. Pass subscription_item_id: to update a different one
+      # (Stripe no longer accepts a top-level quantity on the subscription itself)
       def change_quantity(quantity, **options)
-        subscription_item_id = options.delete(:subscription_item_id) || subscription_items&.first&.id
-        if subscription_item_id
-          ::Stripe::SubscriptionItem.update(subscription_item_id, options.merge(quantity: quantity), stripe_options)
-          @api_record = nil
-        else
-          @api_record = ::Stripe::Subscription.update(processor_id, options.merge(quantity: quantity).merge(expand_options), stripe_options)
-        end
+        subscription_item_id = options.delete(:subscription_item_id) || subscription_items.first.id
+        ::Stripe::SubscriptionItem.update(subscription_item_id, options.merge(quantity: quantity), stripe_options)
+        @api_record = nil
         update(quantity: quantity)
       rescue ::Stripe::StripeError => e
         raise Pay::Stripe::Error, e
@@ -253,6 +244,8 @@ module Pay
           pause_resumes_at: (@api_record.pause_collection&.resumes_at ? Time.at(@api_record.pause_collection&.resumes_at) : nil),
           pause_starts_at: ((behavior == "void") ? Time.at(@api_record.items.first.current_period_end) : nil)
         )
+      rescue ::Stripe::StripeError => e
+        raise Pay::Stripe::Error, e
       end
 
       # Unpauses a subscription
@@ -265,6 +258,8 @@ module Pay
           pause_resumes_at: nil,
           pause_starts_at: nil
         )
+      rescue ::Stripe::StripeError => e
+        raise Pay::Stripe::Error, e
       end
 
       def resumable?
@@ -285,7 +280,7 @@ module Pay
           }.merge(expand_options),
             stripe_options)
         end
-        update(ends_at: nil, status: :active)
+        update(ends_at: nil, status: @api_record.status)
       rescue ::Stripe::StripeError => e
         raise Pay::Stripe::Error, e
       end
@@ -293,7 +288,7 @@ module Pay
       def swap(plan, **options)
         raise ArgumentError, "plan must be a string" unless plan.is_a?(String)
 
-        prorate = options.fetch(:prorate) { true }
+        prorate = options.delete(:prorate) { true }
         proration_behavior = options.delete(:proration_behavior) || (prorate ? "always_invoice" : "none")
 
         @api_record = ::Stripe::Subscription.update(
@@ -309,7 +304,7 @@ module Pay
 
         # Validate that swap was successful and handle SCA if needed
         if (payment_intent_id = @api_record.latest_invoice.payments.first&.payment&.payment_intent)
-          Pay::Payment.from_id(payment_intent_id).validate
+          Pay::Payment.from_id(payment_intent_id, stripe_account: stripe_account).validate
         end
 
         sync!(object: @api_record)
@@ -330,6 +325,8 @@ module Pay
 
       def preview_invoice(**options)
         ::Stripe::Invoice.create_preview(options.merge(subscription: processor_id), stripe_options)
+      rescue ::Stripe::StripeError => e
+        raise Pay::Stripe::Error, e
       end
 
       # Retries the latest invoice for a Past Due subscription and attempts to pay it
@@ -338,9 +335,12 @@ module Pay
         payment_intent = ::Stripe::PaymentIntent.retrieve({id: payment_intent_id}, stripe_options)
 
         payment_intent = if payment_intent.status == "requires_payment_method"
-          ::Stripe::PaymentIntent.confirm(payment_intent_id, {payment_method: customer.default_payment_method.processor_id}, stripe_options)
+          payment_method = customer.default_payment_method
+          raise Pay::Stripe::Error, "no default payment method to retry the payment with" if payment_method.nil?
+
+          ::Stripe::PaymentIntent.confirm(payment_intent_id, {payment_method: payment_method.processor_id}, stripe_options)
         else
-          ::Stripe::PaymentIntent.confirm(payment_intent_id, stripe_options)
+          ::Stripe::PaymentIntent.confirm(payment_intent_id, {}, stripe_options)
         end
         Pay::Payment.new(payment_intent).validate
       rescue ::Stripe::StripeError => e
@@ -348,14 +348,23 @@ module Pay
       end
 
       # Looks up open invoices for a subscription and attempts to pay them
+      #
+      # Invoices no longer expose a `payment_intent` directly, so the PaymentIntent is looked up through the invoice's payments
       def pay_open_invoices
-        ::Stripe::Invoice.list({subscription: processor_id, status: :open}, stripe_options).auto_paging_each do |invoice|
-          retry_failed_payment(payment_intent_id: invoice.payment_intent)
+        ::Stripe::Invoice.list({subscription: processor_id, status: :open, expand: ["data.payments"]}, stripe_options).auto_paging_each do |invoice|
+          payment_intent_id = invoice.payments.first&.payment&.payment_intent
+          retry_failed_payment(payment_intent_id: payment_intent_id) if payment_intent_id
         end
+      rescue ::Stripe::StripeError => e
+        raise Pay::Stripe::Error, e
       end
 
+      # Returns the Stripe::PaymentIntent for the latest invoice, if there is one
       def latest_payment
-        api_record(expand: ["latest_invoice.payment_intent"]).latest_invoice.payment_intent
+        payment_intent_id = api_record.latest_invoice&.payments&.first&.payment&.payment_intent
+        ::Stripe::PaymentIntent.retrieve({id: payment_intent_id}, stripe_options) if payment_intent_id
+      rescue ::Stripe::StripeError => e
+        raise Pay::Stripe::Error, e
       end
 
       private

data/app/models/pay/subscription.rb

@@ -1,7 +1,5 @@
 module Pay
   class Subscription < Pay::ApplicationRecord
-    STATUSES = %w[incomplete incomplete_expired trialing active past_due canceled unpaid paused]
-
     # Associations
     belongs_to :customer, touch: true
     belongs_to :payment_method, optional: true, primary_key: :processor_id
@@ -9,7 +7,7 @@ module Pay
 
     # Scopes
     scope :for_name, ->(name) { where(name: name) }
-    scope :on_trial, -> { where(status: ["on_trial", "trialing", "active"]).where("trial_ends_at > ?", Time.current) }
+    scope :on_trial, -> { where(status: ["trialing", "active"]).where("trial_ends_at > ?", Time.current) }
     scope :canceled, -> { where.not(ends_at: nil) }
     scope :cancelled, -> { canceled }
     scope :on_grace_period, -> { where("#{table_name}.ends_at IS NOT NULL AND #{table_name}.ends_at > ?", Time.current) }
@@ -29,7 +27,7 @@ module Pay
 
     # Validations
     validates :name, presence: true
-    validates :processor_id, presence: true, uniqueness: {scope: :customer_id, case_sensitive: true}
+    validates :processor_id, presence: true
     validates :processor_plan, presence: true
     validates :quantity, presence: true, numericality: {only_integer: true, greater_than_or_equal_to: 0}
     validates :status, presence: true
@@ -54,18 +52,10 @@ module Pay
       reload
     end
 
-    def skip_trial
-      self.trial_ends_at = nil
-    end
-
     def generic_trial?
       fake_processor? && trial_ends_at?
     end
 
-    def has_trial?
-      trial_ends_at?
-    end
-
     # Does not include the last second of the trial
     def on_trial?
       return false if ended?

data/app/views/layouts/pay/application.html.erb

@@ -4,8 +4,6 @@
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width, initial-scale=1" />
   <title>Payment Confirmation - <%= Pay.business_name %></title>
-  <%#= stylesheet_link_tag    "pay/application", media: "all" %>
-  <%#= javascript_include_tag "pay/application" %>
   <%= csrf_meta_tags %>
 
   <link href="https://unpkg.com/tailwindcss@^2.2/dist/tailwind.min.css" rel="stylesheet">

data/app/views/pay/payments/show.html.erb

@@ -1,8 +1,12 @@
 <div
   data-controller="payment-intent"
+  data-payment-intent-public-key-value="<%= Pay::Stripe.public_key %>"
+  data-payment-intent-stripe-account-value="<%= @payment.stripe_account %>"
   data-payment-intent-client-secret-value="<%= @payment.client_secret %>"
   data-payment-intent-status-value="<%= @payment.status %>"
   data-payment-intent-customer-value="<%= @payment.customer %>"
+  data-payment-intent-name-missing-message-value="<%= t("pay.requires_action.name_missing") %>"
+  data-payment-intent-confirmed-message-value="<%= t("pay.requires_action.success") %>"
   class="h-screen md:flex md:justify-center md:items-center">
   <div class="w-full max-w-lg">
     <!-- Status Messages -->
@@ -54,7 +58,7 @@
         </div>
       <% end %>
 
-      <%= sanitize link_to(t("pay.back"), @redirect_to, class: "inline-block w-full px-4 py-3 bg-gray-100 hover:bg-gray-200 text-center text-gray-600 rounded-lg") %>
+      <%= link_to t("pay.back"), @redirect_to, class: "inline-block w-full px-4 py-3 bg-gray-100 hover:bg-gray-200 text-center text-gray-600 rounded-lg" %>
     </div>
 
     <p class="text-center text-gray-500 text-sm">
@@ -64,26 +68,33 @@
 </div>
 
 <script type="module">
-  window.stripe = Stripe('<%= Pay::Stripe.public_key %>')
-
   import { Application, Controller } from 'https://unpkg.com/@hotwired/stimulus/dist/stimulus.js'
   const application = Application.start()
 
   application.register('payment-intent', class extends Controller {
     static targets = ["error", "errorMessage", "success", "successMessage", "form", "button", "name", "card", "cardFields"]
     static values = {
+      publicKey: String,
+      stripeAccount: String,
       clientSecret: String,
       customer: String,
       status: String,
+      nameMissingMessage: String,
+      confirmedMessage: String,
       errorMessage: String,
       successMessage: String,
       complete: Boolean,
       processing: Boolean
     }
 
+    // Value callbacks run before connect(), so Stripe.js must be ready here
+    initialize() {
+      this.stripe = Stripe(this.publicKeyValue, this.stripeAccountValue ? {stripeAccount: this.stripeAccountValue} : {})
+    }
+
     connect() {
       if (this.hasCardTarget) {
-        this.elements = stripe.elements({clientSecret: this.clientSecretValue})
+        this.elements = this.stripe.elements({clientSecret: this.clientSecretValue})
         this.payment =  this.elements.create('payment')
         this.payment.mount(this.cardTarget)
       }
@@ -93,7 +104,7 @@
       switch(this.statusValue) {
         case "requires_action":
           this.processingValue = true
-          stripe.confirmPayment({clientSecret: this.clientSecretValue, confirmParams: { return_url: document.location.href }}).then(this.handleConfirmResult.bind(this))
+          this.stripe.confirmPayment({clientSecret: this.clientSecretValue, confirmParams: { return_url: document.location.href }}).then(this.handleConfirmResult.bind(this))
           break
         case "requires_payment_method":
           this.cardFieldsTarget.classList.toggle("hidden", false)
@@ -103,7 +114,7 @@
 
     confirmPayment() {
       this.processingValue = true
-      stripe.confirmPayment({elements: this.elements, confirmParams: { return_url: document.location.href }}).then(this.handleConfirmResult.bind(this))
+      this.stripe.confirmPayment({elements: this.elements, confirmParams: { return_url: document.location.href }}).then(this.handleConfirmResult.bind(this))
     }
 
     handleConfirmResult(result) {
@@ -112,14 +123,14 @@
       if (result.error) {
         if (result.error.code === 'parameter_invalid_empty' &&
           result.error.param === 'payment_method_data[billing_details][name]') {
-          this.errorMessageValue = '<%=t "pay.requires_action.name_missing" %>'
+          this.errorMessageValue = this.nameMissingMessageValue
         } else {
           this.errorMessageValue = result.error.message
           this.statusValue = result.error.payment_intent.status
         }
       } else {
         this.completeValue = true
-        this.successMessageValue = '<%=t "pay.requires_action.success" %>'
+        this.successMessageValue = this.confirmedMessageValue
       }
     }
 

data/app/views/pay/user_mailer/payment_action_required.html.erb

@@ -1,5 +1,5 @@
 <h3>Extra confirmation is needed to process your payment</h3>
 <p>Your <%= Pay.application_name %> subscription requires confirmation to process your payment to continue access.</p>
-<p><%= link_to "Confirm your payment", pay.payment_url(params[:payment_intent_id]) %></p>
+<p><%= link_to "Confirm your payment", pay.payment_url(params[:payment_intent_id], stripe_account: params[:stripe_account]) %></p>
 <p>If you have any questions, please hit reply and let us know.</p>
 <p>— The <%= Pay.application_name %> Team</p>

data/app/views/pay/user_mailer/payment_action_required.text.erb

@@ -2,7 +2,7 @@ Extra confirmation is needed to process your payment
 
 Your <%= Pay.application_name %> subscription requires confirmation to process your payment to continue access.
 
-Confirm your payment: <%= pay.payment_url(params[:payment_intent_id]) %>
+Confirm your payment: <%= pay.payment_url(params[:payment_intent_id], stripe_account: params[:stripe_account]) %>
 
 If you have any questions, please hit reply and let us know.
 

data/lib/pay/braintree/webhooks/subscription.rb

@@ -0,0 +1,15 @@
+module Pay
+  module Braintree
+    module Webhooks
+      # Every Braintree subscription event is handled the same way: sync the subscription
+      class Subscription
+        def call(event)
+          subscription = event.subscription
+          return if subscription.nil?
+
+          Pay::Braintree::Subscription.sync(subscription.id)
+        end
+      end
+    end
+  end
+end

data/lib/pay/braintree/webhooks/subscription_canceled.rb

@@ -3,13 +3,7 @@
 module Pay
   module Braintree
     module Webhooks
-      class SubscriptionCanceled
-        def call(event)
-          subscription = event.subscription
-          return if subscription.nil?
-
-          Pay::Braintree::Subscription.sync(subscription.id)
-        end
+      class SubscriptionCanceled < Subscription
       end
     end
   end

data/lib/pay/braintree/webhooks/subscription_expired.rb

@@ -3,13 +3,7 @@
 module Pay
   module Braintree
     module Webhooks
-      class SubscriptionExpired
-        def call(event)
-          subscription = event.subscription
-          return if subscription.nil?
-
-          Pay::Braintree::Subscription.sync(subscription.id)
-        end
+      class SubscriptionExpired < Subscription
       end
     end
   end

data/lib/pay/braintree/webhooks/subscription_trial_ended.rb

@@ -3,13 +3,7 @@
 module Pay
   module Braintree
     module Webhooks
-      class SubscriptionTrialEnded
-        def call(event)
-          subscription = event.subscription
-          return if subscription.nil?
-
-          Pay::Braintree::Subscription.sync(subscription.id)
-        end
+      class SubscriptionTrialEnded < Subscription
       end
     end
   end

data/lib/pay/braintree/webhooks/subscription_went_active.rb

@@ -1,15 +1,9 @@
-# A subscription's first authorized transaction is created, or a successful transaction moves a subscription from the Past Due status to the Active status. Subscriptions with trial periods will not trigger this notification when they move from the trial period into the first billing cycle.
+# A subscription's first authorized transaction is created, or a successful transaction moves a subscription from the Past Due status to the Active status.
 
 module Pay
   module Braintree
     module Webhooks
-      class SubscriptionWentActive
-        def call(event)
-          subscription = event.subscription
-          return if subscription.nil?
-
-          Pay::Braintree::Subscription.sync(subscription.id)
-        end
+      class SubscriptionWentActive < Subscription
       end
     end
   end

data/lib/pay/braintree/webhooks/subscription_went_past_due.rb

@@ -1,15 +1,9 @@
-# A subscription has moved from the Active status to the Past Due status. This will only be triggered when the initial transaction in a billing cycle is declined. Once the status moves to past due, it will not be triggered again in that billing cycle.
+# A subscription already exists and fails to create a successful charge.
 
 module Pay
   module Braintree
     module Webhooks
-      class SubscriptionWentPastDue
-        def call(event)
-          subscription = event.subscription
-          return if subscription.nil?
-
-          Pay::Braintree::Subscription.sync(subscription.id)
-        end
+      class SubscriptionWentPastDue < Subscription
       end
     end
   end

data/lib/pay/braintree.rb

@@ -27,9 +27,9 @@ module Pay
     end
 
     module Webhooks
+      autoload :Subscription, "pay/braintree/webhooks/subscription"
       autoload :SubscriptionCanceled, "pay/braintree/webhooks/subscription_canceled"
       autoload :SubscriptionChargedSuccessfully, "pay/braintree/webhooks/subscription_charged_successfully"
-      autoload :SubscriptionChargedUnsuccessfully, "pay/braintree/webhooks/subscription_charged_unsuccessfully"
       autoload :SubscriptionExpired, "pay/braintree/webhooks/subscription_expired"
       autoload :SubscriptionTrialEnded, "pay/braintree/webhooks/subscription_trial_ended"
       autoload :SubscriptionWentActive, "pay/braintree/webhooks/subscription_went_active"
@@ -73,7 +73,6 @@ module Pay
       Pay::Webhooks.configure do |events|
         events.subscribe "braintree.subscription_canceled", Pay::Braintree::Webhooks::SubscriptionCanceled.new
         events.subscribe "braintree.subscription_charged_successfully", Pay::Braintree::Webhooks::SubscriptionChargedSuccessfully.new
-        events.subscribe "braintree.subscription_charged_unsuccessfully", Pay::Braintree::Webhooks::SubscriptionChargedUnsuccessfully.new
         events.subscribe "braintree.subscription_expired", Pay::Braintree::Webhooks::SubscriptionExpired.new
         events.subscribe "braintree.subscription_trial_ended", Pay::Braintree::Webhooks::SubscriptionTrialEnded.new
         events.subscribe "braintree.subscription_went_active", Pay::Braintree::Webhooks::SubscriptionWentActive.new

data/lib/pay/currency.rb

@@ -65,10 +65,6 @@ module Pay
       attributes["format"]
     end
 
-    def subunit?
-      subunit.blank?
-    end
-
     def subunit
       attributes["subunit"]
     end