pay 2.5.0 → 2.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8aa4f779f21c561b6e8b48df4908424198b09413c0e2b580d7d6d2610e4d7429
-  data.tar.gz: c62e136c8ae6ffed79028922aedfe59f14e77ca235ae407aa5acaed3299918d5
+  metadata.gz: f67175eed41645fc10868070414e33e205dc6970be39038715fbde5c18496932
+  data.tar.gz: bd725f34c55707aaf30c1e46ecc111a9c00b69f8275d87c7d94f8640b24d84c2
 SHA512:
-  metadata.gz: 2154c6f3551b6089c470c71280c2ba9c810858954290fce62c67f2ca502822a4504447ebca822ac1b01f763c6c94095202693dc5b0d75e6dde4f89464530180e
-  data.tar.gz: 4d497228db1c45863ad0157bca179957f875705621b968eb1d4c0318c3e4f7ab35692260bb838a7f6c63aa39e704ac3398de535804d512461db1a8ac568239c8
+  metadata.gz: 47b06c20aef2c34454f40bb734c4d1bdd648e9f9f4380c7b5c8d246357036f46b92511bc36ebf7b3b1ec00234700848ad3b12b1eb76c2e274a420e5bc650608b
+  data.tar.gz: 033e3b12a1a1a6f9b7b7bb2e447cb4a1acfb0cf3d35da7d5f00e187f6301d5cc59a9a3bec0d1577f8a6764286d93dbfefe16553939fc8c83213ee1c6668b09b9

data/app/models/pay/charge.rb

@@ -1,5 +1,5 @@
 module Pay
-  class Charge < ApplicationRecord
+  class Charge < Pay::ApplicationRecord
     self.table_name = Pay.chargeable_table
 
     # Only serialize for non-json columns
@@ -18,13 +18,32 @@ module Pay
     validates :processor_id, presence: true
     validates :card_type, presence: true
 
+    store_accessor :data, :paddle_receipt_url
+
+    # Helpers for payment processors
+    %w[braintree stripe paddle].each do |processor_name|
+      define_method "#{processor_name}?" do
+        processor == processor_name
+      end
+
+      scope processor_name, -> { where(processor: processor_name) }
+    end
+
+    def payment_processor
+      @payment_processor ||= payment_processor_for(processor).new(self)
+    end
+
+    def payment_processor_for(name)
+      "Pay::#{name.to_s.classify}::Charge".constantize
+    end
+
     def processor_charge
-      send("#{processor}_charge")
+      payment_processor.charge
     end
 
     def refund!(refund_amount = nil)
       refund_amount ||= amount
-      send("#{processor}_refund!", refund_amount)
+      payment_processor.refund!(refund_amount)
     end
 
     def charged_to

data/app/models/pay/subscription.rb

@@ -1,5 +1,5 @@
 module Pay
-  class Subscription < ApplicationRecord
+  class Subscription < Pay::ApplicationRecord
     self.table_name = Pay.subscription_table
 
     STATUSES = %w[incomplete incomplete_expired trialing active past_due canceled unpaid paused]
@@ -27,6 +27,11 @@ module Pay
     scope :incomplete, -> { where(status: :incomplete) }
     scope :past_due, -> { where(status: :past_due) }
 
+    # TODO: Include these with a module
+    store_accessor :data, :paddle_update_url
+    store_accessor :data, :paddle_cancel_url
+    store_accessor :data, :paddle_paused_from
+
     attribute :prorate, :boolean, default: true
 
     # Helpers for payment processors
@@ -38,6 +43,21 @@ module Pay
       scope processor_name, -> { where(processor: processor_name) }
     end
 
+    def payment_processor
+      @payment_processor ||= payment_processor_for(processor).new(self)
+    end
+
+    def payment_processor_for(name)
+      "Pay::#{name.to_s.classify}::Subscription".constantize
+    end
+
+    delegate :on_grace_period?,
+      :paused?,
+      :pause,
+      :cancel,
+      :cancel_now!,
+      to: :payment_processor
+
     def no_prorate
       self.prorate = false
     end
@@ -58,11 +78,6 @@ module Pay
       canceled?
     end
 
-    def on_grace_period?
-      return unless processor?
-      send("#{processor}_on_grace_period?")
-    end
-
     def active?
       ["trialing", "active"].include?(status) && (ends_at.nil? || on_grace_period? || on_trial?)
     end
@@ -79,30 +94,14 @@ module Pay
       past_due? || incomplete?
     end
 
-    def paused?
-      send("#{processor}_paused?")
-    end
-
-    def pause
-      send("#{processor}_pause")
-    end
-
-    def cancel
-      send("#{processor}_cancel")
-    end
-
-    def cancel_now!
-      send("#{processor}_cancel_now!")
-    end
-
     def resume
-      send("#{processor}_resume")
+      payment_processor.resume
       update(ends_at: nil, status: "active")
       self
     end
 
     def swap(plan)
-      send("#{processor}_swap", plan)
+      payment_processor.swap(plan)
       update(processor_plan: plan, ends_at: nil)
     end
 

data/app/views/pay/stripe/_checkout_button.html.erb

@@ -0,0 +1,21 @@
+<%= button_tag title,
+  id: "checkout-#{session.id}",
+  class: local_assigns[:class],
+  style: (local_assigns[:class] || local_assigns[:style]) ? local_assigns[:style] : 'background-color:#6772E5;color:#FFF;padding:8px 12px;border:0;border-radius:4px;font-size:1em'
+%>
+<%= tag.div id: "error-for-#{session.id}" %>
+
+<script>
+  (() => {
+    const checkoutButton = document.getElementById("checkout-<%= session.id %>");
+    checkoutButton.addEventListener('click', function () {
+      Stripe("<%= Pay::Stripe.public_key %>").redirectToCheckout({
+        sessionId: '<%= session.id %>'
+      }).then(function (result) {
+        if (result.error) {
+            document.getElementById('error-message').innerText = result.error.message;
+          }
+      });
+    });
+  })()
+</script>

data/lib/pay.rb

@@ -1,22 +1,19 @@
 require "pay/version"
 require "pay/engine"
-require "pay/billable"
-require "pay/receipts"
-require "pay/payment"
 require "pay/errors"
 
 module Pay
-  module Webhooks
-    autoload :Delegator, "pay/webhooks/delegator"
+  autoload :Billable, "pay/billable"
+  autoload :Env, "pay/env"
+  autoload :Payment, "pay/payment"
+  autoload :Receipts, "pay/receipts"
 
-    class << self
-      delegate :configure, :instrument, to: :delegator
+  # Payment processors
+  autoload :Braintree, "pay/braintree"
+  autoload :Paddle, "pay/paddle"
+  autoload :Stripe, "pay/stripe"
 
-      def delegator
-        @delegator ||= Delegator.new
-      end
-    end
-  end
+  autoload :Webhooks, "pay/webhooks"
 
   # Define who owns the subscription
   mattr_accessor :billable_class

data/lib/pay/billable.rb

@@ -17,9 +17,6 @@ module Pay
 
     included do |base|
       include Pay::Billable::SyncEmail
-      include Pay::Stripe::Billable if defined? ::Stripe
-      include Pay::Braintree::Billable if defined? ::Braintree
-      include Pay::Paddle::Billable if defined? ::PaddlePay
 
       has_many :charges, class_name: Pay.chargeable_class, foreign_key: :owner_id, inverse_of: :owner, as: :owner
       has_many :subscriptions, class_name: Pay.subscription_class, foreign_key: :owner_id, inverse_of: :owner, as: :owner
@@ -29,17 +26,34 @@ module Pay
       attribute :card_token, :string
     end
 
+    def payment_processor
+      @payment_processor ||= payment_processor_for(processor).new(self)
+    end
+
+    def payment_processor_for(name)
+      "Pay::#{name.to_s.classify}::Billable".constantize
+    end
+
+    # Reset the payment processor when it changes
     def processor=(value)
       super(value)
       self.processor_id = nil if processor_changed?
+      @payment_processor = nil
     end
 
+    def processor
+      super.inquiry
+    end
+
+    delegate :charge, to: :payment_processor
+    delegate :subscribe, to: :payment_processor
+    delegate :update_card, to: :payment_processor
+
     def customer
-      check_for_processor
       raise Pay::Error, I18n.t("errors.email_required") if email.nil?
 
-      customer = send("#{processor}_customer")
-      update_card(card_token) if card_token.present?
+      customer = payment_processor.customer
+      payment_processor.update_card(card_token) if card_token.present?
       customer
     end
 
@@ -47,20 +61,9 @@ module Pay
       [try(:first_name), try(:last_name)].compact.join(" ")
     end
 
-    def charge(amount_in_cents, options = {})
-      check_for_processor
-      send("create_#{processor}_charge", amount_in_cents, options)
-    end
-
-    def subscribe(name: Pay.default_product_name, plan: Pay.default_plan_name, **options)
-      check_for_processor
-      send("create_#{processor}_subscription", name, plan, options)
-    end
-
-    def update_card(token)
-      check_for_processor
-      customer if processor_id.nil?
-      send("update_#{processor}_card", token)
+    def create_setup_intent
+      ActiveSupport::Deprecation.warn("This method will be removed in the next release. Use `@billable.payment_processor.create_setup_intent` instead.")
+      payment_processor.create_setup_intent
     end
 
     def on_trial?(name: Pay.default_product_name, plan: nil)
@@ -77,8 +80,7 @@ module Pay
     end
 
     def processor_subscription(subscription_id, options = {})
-      check_for_processor
-      send("#{processor}_subscription", subscription_id, options)
+      payment_processor.processor_subscription(subscription_id, options)
     end
 
     def subscribed?(name: Pay.default_product_name, processor_plan: nil)
@@ -100,11 +102,13 @@ module Pay
     end
 
     def invoice!(options = {})
-      send("#{processor}_invoice!", options)
+      ActiveSupport::Deprecation.warn("This will be removed in the next release. Use `@billable.payment_processor.invoice!` instead.")
+      payment_processor.invoice!(options)
     end
 
     def upcoming_invoice
-      send("#{processor}_upcoming_invoice")
+      ActiveSupport::Deprecation.warn("This will be removed in the next release. Use `@billable.payment_processor.upcoming_invoice` instead.")
+      payment_processor.upcoming_invoice
     end
 
     def stripe?
@@ -116,7 +120,7 @@ module Pay
     end
 
     def paypal?
-      braintree? && card_type == "PayPal"
+      card_type == "PayPal"
     end
 
     def paddle?
@@ -127,14 +131,8 @@ module Pay
       subscription(name: name)&.has_incomplete_payment?
     end
 
-    private
-
-    def check_for_processor
-      raise StandardError, I18n.t("errors.no_processor", class_name: self.class.name) unless processor
-    end
-
     # Used for creating a Pay::Subscription in the database
-    def create_subscription(subscription, processor, name, plan, options = {})
+    def create_pay_subscription(subscription, processor, name, plan, options = {})
       options[:quantity] ||= 1
 
       options.merge!(
@@ -142,12 +140,14 @@ module Pay
         processor: processor,
         processor_id: subscription.id,
         processor_plan: plan,
-        trial_ends_at: send("#{processor}_trial_end_date", subscription),
+        trial_ends_at: payment_processor.trial_end_date(subscription),
         ends_at: nil
       )
       subscriptions.create!(options)
     end
 
+    private
+
     def default_generic_trial?(name, plan)
       # Generic trials don't have plans or custom names
       plan.nil? && name == "default" && on_generic_trial?

data/lib/pay/billable/sync_email.rb

@@ -23,7 +23,7 @@ module Pay
       end
 
       def sync_email_with_processor
-        send("update_#{processor}_email!")
+        payment_processor.update_email!
       end
 
       private

data/lib/pay/braintree.rb

@@ -1,16 +1,24 @@
-require "pay/env"
-require "pay/braintree/billable"
-require "pay/braintree/charge"
-require "pay/braintree/subscription"
-require "pay/braintree/webhooks"
-
 module Pay
   module Braintree
-    include Env
+    autoload :Billable, "pay/braintree/billable"
+    autoload :Charge, "pay/braintree/charge"
+    autoload :Subscription, "pay/braintree/subscription"
+    autoload :Error, "pay/braintree/error"
+    autoload :AuthorizationError, "pay/braintree/authorization_error"
+
+    module Webhooks
+      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"
+      autoload :SubscriptionWentPastDue, "pay/braintree/webhooks/subscription_went_past_due"
+    end
 
-    extend self
+    extend Env
 
-    def setup
+    def self.setup
       Pay.braintree_gateway = ::Braintree::Gateway.new(
         environment: environment.to_sym,
         merchant_id: merchant_id,
@@ -18,25 +26,35 @@ module Pay
         private_key: private_key
       )
 
-      Pay.charge_model.include Pay::Braintree::Charge
-      Pay.subscription_model.include Pay::Braintree::Subscription
-      Pay.billable_models.each { |model| model.include Pay::Braintree::Billable }
+      configure_webhooks
     end
 
-    def public_key
+    def self.public_key
       find_value_by_name(:braintree, :public_key)
     end
 
-    def private_key
+    def self.private_key
       find_value_by_name(:braintree, :private_key)
     end
 
-    def merchant_id
+    def self.merchant_id
       find_value_by_name(:braintree, :merchant_id)
     end
 
-    def environment
+    def self.environment
       find_value_by_name(:braintree, :environment) || "sandbox"
     end
+
+    def self.configure_webhooks
+      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
+        events.subscribe "braintree.subscription_went_past_due", Pay::Braintree::Webhooks::SubscriptionWentPastDue.new
+      end
+    end
   end
 end

data/lib/pay/braintree/authorization_error.rb

@@ -0,0 +1,9 @@
+module Pay
+  module Braintree
+    class AuthorizationError < Braintree::Error
+      def message
+        I18n.t("errors.braintree.authorization")
+      end
+    end
+  end
+end

data/lib/pay/braintree/billable.rb

@@ -1,16 +1,23 @@
 module Pay
   module Braintree
-    module Billable
-      extend ActiveSupport::Concern
-
-      included do
-        scope :braintree, -> { where(processor: :braintree) }
+    class Billable
+      attr_reader :billable
+
+      delegate :processor_id,
+        :processor_id?,
+        :email,
+        :customer_name,
+        :card_token,
+        to: :billable
+
+      def initialize(billable)
+        @billable = billable
       end
 
       # Handles Billable#customer
       #
       # Returns Braintree::Customer
-      def braintree_customer
+      def customer
         if processor_id?
           gateway.customer.find(processor_id)
         else
@@ -22,16 +29,16 @@ module Pay
           )
           raise Pay::Braintree::Error, result unless result.success?
 
-          update(processor: "braintree", processor_id: result.customer.id)
+          billable.update(processor: "braintree", processor_id: result.customer.id)
 
           if card_token.present?
-            update_braintree_card_on_file result.customer.payment_methods.last
+            update_card_on_file result.customer.payment_methods.last
           end
 
           result.customer
         end
       rescue ::Braintree::AuthorizationError
-        raise BraintreeAuthorizationError
+        raise Pay::Braintree::AuthorizationError
       rescue ::Braintree::BraintreeError => e
         raise Pay::Braintree::Error, e
       end
@@ -39,7 +46,7 @@ module Pay
       # Handles Billable#charge
       #
       # Returns a Pay::Charge
-      def create_braintree_charge(amount, options = {})
+      def charge(amount, options = {})
         args = {
           amount: amount.to_i / 100.0,
           customer_id: customer.id,
@@ -49,7 +56,7 @@ module Pay
         result = gateway.transaction.sale(args)
         raise Pay::Braintree::Error, result unless result.success?
 
-        save_braintree_transaction(result.transaction)
+        save_transaction(result.transaction)
       rescue ::Braintree::AuthorizationError
         raise Pay::Braintree::AuthorizationError
       rescue ::Braintree::BraintreeError => e
@@ -59,7 +66,7 @@ module Pay
       # Handles Billable#subscribe
       #
       # Returns Pay::Subscription
-      def create_braintree_subscription(name, plan, options = {})
+      def subscribe(name: Pay.default_product_name, plan: Pay.default_plan_name, **options)
         token = customer.payment_methods.find(&:default?).try(:token)
         raise Pay::Error, "Customer has no default payment method" if token.nil?
 
@@ -76,7 +83,7 @@ module Pay
         result = gateway.subscription.create(subscription_options)
         raise Pay::Braintree::Error, result unless result.success?
 
-        create_subscription(result.subscription, "braintree", name, plan, status: :active)
+        billable.create_pay_subscription(result.subscription, "braintree", name, plan, status: :active)
       rescue ::Braintree::AuthorizationError
         raise Pay::Braintree::AuthorizationError
       rescue ::Braintree::BraintreeError => e
@@ -86,7 +93,7 @@ module Pay
       # Handles Billable#update_card
       #
       # Returns true if successful
-      def update_braintree_card(token)
+      def update_card(token)
         result = gateway.payment_method.create(
           customer_id: processor_id,
           payment_method_nonce: token,
@@ -97,7 +104,7 @@ module Pay
         )
         raise Pay::Braintree::Error, result unless result.success?
 
-        update_braintree_card_on_file result.payment_method
+        update_card_on_file result.payment_method
         update_subscriptions_to_payment_method(result.payment_method.token)
         true
       rescue ::Braintree::AuthorizationError
@@ -106,29 +113,25 @@ module Pay
         raise Pay::Braintree::Error, e
       end
 
-      def update_braintree_email!
-        braintree_customer.update(
-          email: email,
-          first_name: try(:first_name),
-          last_name: try(:last_name)
-        )
+      def update_email!
+        gateway.customer.update(processor_id, email: email, first_name: try(:first_name), last_name: try(:last_name))
       end
 
-      def braintree_trial_end_date(subscription)
+      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 update_subscriptions_to_payment_method(token)
-        subscriptions.braintree.each do |subscription|
+        billable.subscriptions.braintree.each do |subscription|
           if subscription.active?
             gateway.subscription.update(subscription.processor_id, {payment_method_token: token})
           end
         end
       end
 
-      def braintree_subscription(subscription_id, options = {})
+      def processor_subscription(subscription_id, options = {})
         gateway.subscription.find(subscription_id)
       end
 
@@ -140,11 +143,11 @@ module Pay
         # pass
       end
 
-      def save_braintree_transaction(transaction)
+      def save_transaction(transaction)
         attrs = card_details_for_braintree_transaction(transaction)
         attrs[:amount] = transaction.amount.to_f * 100
 
-        charge = charges.find_or_initialize_by(
+        charge = billable.charges.find_or_initialize_by(
           processor: :braintree,
           processor_id: transaction.id
         )
@@ -158,10 +161,10 @@ module Pay
         Pay.braintree_gateway
       end
 
-      def update_braintree_card_on_file(payment_method)
+      def update_card_on_file(payment_method)
         case payment_method
         when ::Braintree::CreditCard
-          update!(
+          billable.update!(
             card_type: payment_method.card_type,
             card_last4: payment_method.last_4,
             card_exp_month: payment_method.expiration_month,
@@ -169,14 +172,14 @@ module Pay
           )
 
         when ::Braintree::PayPalAccount
-          update!(
+          billable.update!(
             card_type: "PayPal",
             card_last4: payment_method.email
           )
         end
 
         # Clear the card token so we don't accidentally update twice
-        self.card_token = nil
+        billable.card_token = nil
       end
 
       def card_details_for_braintree_transaction(transaction)