Use STI for Pay models (#1042)

* WIP STI for Pay models

* Refactor to using STI

* Add upgrade steps

* Fix mysql created_at precision for tests

* Refactor

Author: excid3

CHANGELOG.md

@@ -5,6 +5,9 @@
 ### 8.0.0
 
 * [Breaking] Remove `pay_customer.payment_method_token` virtual attribute. Use `@pay_customer.update_payment_method(token)` instead.
+* [Breaking] Rename `customer` to `api_record`
+* [Breaking] Rename `update_customer!` to `update_api_record`
+* [Breaking] Rename `Pay::PaymentMethod#type` to `Pay::PaymentMethod#payment_method_type`
 * Add Lemon Squeezy support
 * Add `Pay.sync(params)` for automatically syncing Stripe Checkout Sessions and Paddle Billing transactions.
 * Lock Pay::Customer record when creating or updating Stripe customer to handle race conditions. #1027

UPGRADE.md

@@ -2,6 +2,13 @@
 
 Follow this guide to upgrade older Pay versions. These may require database migrations and code changes.
 
+### ** Pay 7.0 to Pay 8.0**
+
+```bash
+rails pay:install:migrations
+rails db:migrate
+```
+
 ## **Pay 6.0 to Pay 7.0**
 
 Pay 7 introduces some changes for Stripe and requires a few additional columns.

app/jobs/pay/customer_sync_job.rb

@@ -1,7 +1,7 @@
 module Pay
   class CustomerSyncJob < ApplicationJob
     def perform(pay_customer_id)
-      Pay::Customer.find(pay_customer_id).update_customer!
+      Pay::Customer.find(pay_customer_id).update_api_record
     rescue ActiveRecord::RecordNotFound
       Rails.logger.info "Couldn't find a Pay::Customer with ID = #{pay_customer_id}"
     end

app/models/concerns/pay/routing.rb

@@ -0,0 +1,13 @@
+module Pay
+  module Routing
+    extend ActiveSupport::Concern
+
+    included do
+      include Rails.application.routes.url_helpers
+    end
+
+    def default_url_options
+      Rails.application.config.action_mailer.default_url_options || {}
+    end
+  end
+end

lib/pay/braintree/charge.rb app/models/pay/braintree/charge.rb

@@ -1,10 +1,6 @@
 module Pay
   module Braintree
-    class Charge
-      attr_reader :pay_charge
-
-      delegate :processor_id, to: :pay_charge
-
+    class Charge < Pay::Charge
       def self.sync(charge_id, object: nil, try: 0, retries: 1)
         object ||= Pay.braintree_gateway.transaction.find(charge_id)
 
@@ -22,19 +18,16 @@ def self.sync(charge_id, object: nil, try: 0, retries: 1)
         end
       end
 
-      def initialize(pay_charge)
-        @pay_charge = pay_charge
-      end
-
-      def charge
+      def api_record
         Pay.braintree_gateway.transaction.find(processor_id)
       rescue ::Braintree::Braintree::Error => e
         raise Pay::Braintree::Error, e
       end
 
-      def refund!(amount_to_refund)
+      def refund!(amount_to_refund = nil)
+        amount_to_refund ||= amount
         Pay.braintree_gateway.transaction.refund(processor_id, amount_to_refund / 100.0)
-        pay_charge.update(amount_refunded: amount_to_refund)
+        update(amount_refunded: amount_to_refund)
       rescue ::Braintree::BraintreeError => e
         raise Pay::Braintree::Error, e
       end

lib/pay/braintree/billable.rb app/models/pay/braintree/customer.rb

@@ -1,46 +1,34 @@
 module Pay
   module Braintree
-    class Billable
-      attr_reader :pay_customer
-
-      delegate :processor_id,
-        :processor_id?,
-        :email,
-        :customer_name,
-        to: :pay_customer
-
-      def initialize(pay_customer)
-        @pay_customer = pay_customer
-      end
+    class Customer < Pay::Customer
+      has_many :charges, dependent: :destroy, class_name: "Pay::Braintree::Charge"
+      has_many :subscriptions, dependent: :destroy, class_name: "Pay::Braintree::Subscription"
+      has_many :payment_methods, dependent: :destroy, class_name: "Pay::Braintree::PaymentMethod"
+      has_one :default_payment_method, -> { where(default: true) }, class_name: "Pay::Braintree::PaymentMethod"
 
       # Returns a hash of attributes for the Stripe::Customer object
-      def customer_attributes
-        owner = pay_customer.owner
-
+      def api_record_attributes
         attributes = case owner.class.pay_braintree_customer_attributes
         when Symbol
-          owner.send(owner.class.pay_braintree_customer_attributes, pay_customer)
+          owner.send(owner.class.pay_braintree_customer_attributes, self)
         when Proc
-          owner.class.pay_braintree_customer_attributes.call(pay_customer)
+          owner.class.pay_braintree_customer_attributes.call(self)
         end
 
-        # Guard against attributes being returned nil
-        attributes ||= {}
-
         first_name, last_name = customer_name.split(" ", 2)
-        {email: email, first_name: first_name, last_name: last_name}.merge(attributes)
+        {email: email, first_name: first_name, last_name: last_name}.merge(attributes || {})
       end
 
       # Retrieve the Braintree::Customer object
       #
       # - If no processor_id is present, creates a Customer.
-      def customer
+      def api_record
         if processor_id?
           gateway.customer.find(processor_id)
         else
-          result = gateway.customer.create(customer_attributes)
+          result = gateway.customer.create(api_record_attributes)
           raise Pay::Braintree::Error, result unless result.success?
-          pay_customer.update!(processor_id: result.customer.id)
+          update!(processor_id: result.customer.id)
           result.customer
         end
       rescue ::Braintree::AuthorizationError => e
@@ -51,15 +39,15 @@ def customer
 
       # Syncs name and email to Braintree::Customer
       # You can also pass in other attributes that will be merged into the default attributes
-      def update_customer!(**attributes)
-        customer unless processor_id?
-        gateway.customer.update(processor_id, customer_attributes.merge(attributes))
+      def update_api_record(**attributes)
+        api_record unless processor_id?
+        gateway.customer.update(processor_id, api_record_attributes.merge(attributes))
       end
 
       def charge(amount, options = {})
         args = {
           amount: amount.to_i / 100.0,
-          customer_id: customer.id,
+          customer_id: processor_id || api_record.id,
           options: {submit_for_settlement: true},
           custom_fields: options.delete(:metadata)
         }.merge(options)
@@ -75,7 +63,7 @@ def charge(amount, options = {})
       end
 
       def subscribe(name: Pay.default_product_name, plan: Pay.default_plan_name, **options)
-        token = customer.payment_methods.find(&:default?).try(:token)
+        token = api_record.payment_methods.find(&:default?).try(:token)
         raise Pay::Error, "Customer has no default payment method" if token.nil?
 
         # Standardize the trial period options
@@ -89,12 +77,15 @@ def subscribe(name: Pay.default_product_name, plan: Pay.default_plan_name, **opt
         result = gateway.subscription.create(subscription_options)
         raise Pay::Braintree::Error, result unless result.success?
 
-        subscription = pay_customer.subscriptions.create!(
+        # Braintree returns dates without time zones, so we'll assume they're UTC
+        trial_end_date = result.subscription.trial_period.present? ? result.subscription.first_billing_date.end_of_day : nil
+
+        subscription = subscriptions.create!(
           name: name,
           processor_id: result.subscription.id,
           processor_plan: plan,
           status: :active,
-          trial_ends_at: trial_end_date(result.subscription),
+          trial_ends_at: trial_end_date,
           ends_at: nil,
           metadata: metadata
         )
@@ -111,10 +102,8 @@ def subscribe(name: Pay.default_product_name, plan: Pay.default_plan_name, **opt
       end
 
       def add_payment_method(token, default: false)
-        customer unless processor_id?
-
         result = gateway.payment_method.create(
-          customer_id: processor_id,
+          customer_id: processor_id || api_record.id,
           payment_method_nonce: token,
           options: {
             make_default: default,
@@ -126,7 +115,7 @@ def add_payment_method(token, default: false)
         pay_payment_method = save_payment_method(result.payment_method, default: default)
 
         # Update existing subscriptions to the new payment method
-        pay_customer.subscriptions.each do |subscription|
+        subscriptions.each do |subscription|
           if subscription.active?
             gateway.subscription.update(subscription.processor_id, {payment_method_token: token})
           end
@@ -139,16 +128,6 @@ def add_payment_method(token, default: false)
         raise Pay::Braintree::Error, e
       end
 
-      def trial_end_date(subscription)
-        return unless subscription.trial_period
-        # Braintree returns dates without time zones, so we'll assume they're UTC
-        subscription.first_billing_date.end_of_day
-      end
-
-      def processor_subscription(subscription_id, options = {})
-        gateway.subscription.find(subscription_id)
-      end
-
       def save_transaction(transaction)
         attrs = card_details_for_braintree_transaction(transaction)
         attrs[:amount] = transaction.amount.to_f * 100
@@ -159,7 +138,7 @@ def save_transaction(transaction)
 
         # Associate charge with subscription if we can
         if transaction.subscription_id
-          pay_subscription = pay_customer.subscriptions.find_by(processor_id: transaction.subscription_id)
+          pay_subscription = subscriptions.find_by(processor_id: transaction.subscription_id)
           pay_subscription ||= Pay::Braintree::Subscription.sync(transaction.subscription_id)
 
           if pay_subscription
@@ -168,7 +147,7 @@ def save_transaction(transaction)
           end
         end
 
-        charge = pay_customer.charges.find_or_initialize_by(processor_id: transaction.id)
+        charge = charges.find_or_initialize_by(processor_id: transaction.id)
         charge.update!(attrs)
         charge
       end
@@ -219,13 +198,13 @@ def save_payment_method(payment_method, default:)
           }
         end
 
-        pay_payment_method = pay_customer.payment_methods.where(processor_id: payment_method.token).first_or_initialize
+        pay_payment_method = payment_methods.where(processor_id: payment_method.token).first_or_initialize
 
-        pay_customer.payment_methods.update_all(default: false) if default
+        payment_methods.update_all(default: false) if default
         pay_payment_method.update!(attributes.merge(default: default))
 
         # Reload the Rails association
-        pay_customer.reload_default_payment_method if default
+        reload_default_payment_method if default
 
         pay_payment_method
       end

lib/pay/braintree/payment_method.rb app/models/pay/braintree/payment_method.rb

@@ -1,10 +1,6 @@
 module Pay
   module Braintree
-    class PaymentMethod
-      attr_reader :pay_payment_method
-
-      delegate :customer, :processor_id, to: :pay_payment_method
-
+    class PaymentMethod < Pay::PaymentMethod
       def self.sync(id, object: nil, try: 0, retries: 1)
         object ||= Pay.braintree_gateway.payment_method.find(id)
 
@@ -14,10 +10,6 @@ def self.sync(id, object: nil, try: 0, retries: 1)
         pay_customer.save_payment_method(object, default: object.default?)
       end
 
-      def initialize(pay_payment_method)
-        @pay_payment_method = pay_payment_method
-      end
-
       # Sets payment method as default on Stripe
       def make_default!
         result = gateway.customer.update(customer.processor_id, default_payment_method_token: processor_id)