pay 2.4.4 → 2.6.3

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,15 +1,24 @@
-require "pay/env"
-require "pay/braintree/billable"
-require "pay/braintree/charge"
-require "pay/braintree/subscription"
-
 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,
@@ -17,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)

data/lib/pay/braintree/charge.rb

@@ -1,26 +1,24 @@
 module Pay
   module Braintree
-    module Charge
-      extend ActiveSupport::Concern
+    class Charge
+      attr_reader :pay_charge
 
-      included do
-        scope :braintree, -> { where(processor: :braintree) }
-      end
+      delegate :processor_id, to: :pay_charge
 
-      def braintree?
-        processor == "braintree"
+      def initialize(pay_charge)
+        @pay_charge = pay_charge
       end
 
-      def braintree_charge
+      def charge
         Pay.braintree_gateway.transaction.find(processor_id)
       rescue ::Braintree::Braintree::Error => e
         raise Pay::Braintree::Error, e
       end
 
-      def braintree_refund!(amount_to_refund)
+      def refund!(amount_to_refund)
         Pay.braintree_gateway.transaction.refund(processor_id, amount_to_refund / 100.0)
 
-        update(amount_refunded: amount_to_refund)
+        pay_charge.update(amount_refunded: amount_to_refund)
       rescue ::Braintree::BraintreeError => e
         raise Pay::Braintree::Error, e
       end

data/lib/pay/braintree/error.rb

@@ -0,0 +1,9 @@
+module Pay
+  module Braintree
+    class Error < Pay::Error
+      def message
+        result.message
+      end
+    end
+  end
+end

data/lib/pay/braintree/subscription.rb

@@ -1,44 +1,64 @@
 module Pay
   module Braintree
-    module Subscription
-      extend ActiveSupport::Concern
+    class Subscription
+      attr_reader :pay_subscription
+
+      delegate :active?,
+        :canceled?,
+        :ends_at,
+        :name,
+        :on_trial?,
+        :owner,
+        :processor_subscription,
+        :processor_id,
+        :prorate,
+        :prorate?,
+        :processor_plan,
+        :quantity?,
+        :quantity,
+        :trial_ends_at,
+        to: :pay_subscription
+
+      def initialize(pay_subscription)
+        @pay_subscription = pay_subscription
+      end
 
-      def braintree_cancel
+      def cancel
         subscription = processor_subscription
 
         if on_trial?
           gateway.subscription.cancel(processor_subscription.id)
-          update(status: :canceled, ends_at: trial_ends_at)
+          pay_subscription.update(status: :canceled, ends_at: trial_ends_at)
         else
           gateway.subscription.update(subscription.id, {
             number_of_billing_cycles: subscription.current_billing_cycle
           })
-          update(status: :canceled, ends_at: subscription.billing_period_end_date.to_date)
+          pay_subscription.update(status: :canceled, ends_at: subscription.billing_period_end_date.to_date)
         end
       rescue ::Braintree::BraintreeError => e
         raise Pay::Braintree::Error, e
       end
 
-      def braintree_cancel_now!
+      def cancel_now!
         gateway.subscription.cancel(processor_subscription.id)
-        update(status: :canceled, ends_at: Time.zone.now)
+        pay_subscription.update(status: :canceled, ends_at: Time.zone.now)
       rescue ::Braintree::BraintreeError => e
         raise Pay::Braintree::Error, e
       end
 
-      def braintree_on_grace_period?
+      def on_grace_period?
         canceled? && Time.zone.now < ends_at
       end
 
-      def braintree_paused?
+      def paused?
         false
       end
 
-      def braintree_pause
+      def pause
         raise NotImplementedError, "Braintree does not support pausing subscriptions"
       end
 
-      def braintree_resume
+      def resume
         unless on_grace_period?
           raise StandardError, "You can only resume subscriptions within their grace period."
         end
@@ -53,7 +73,6 @@ module Pay
             trial_duration: duration.to_i,
             trial_duration_unit: :day
           )
-
         else
           subscription = processor_subscription
 
@@ -63,12 +82,12 @@ module Pay
           })
         end
 
-        update(status: :active)
+        pay_subscription.update(status: :active)
       rescue ::Braintree::BraintreeError => e
         raise Pay::Braintree::Error, e
       end
 
-      def braintree_swap(plan)
+      def swap(plan)
         if on_grace_period? && processor_plan == plan
           resume
           return
@@ -99,7 +118,7 @@ module Pay
         })
 
         if result.success?
-          update(status: :active, processor_plan: braintree_plan.id, ends_at: nil)
+          pay_subscription.update(status: :active, processor_plan: braintree_plan.id, ends_at: nil)
         else
           raise Error, "Braintree failed to swap plans: #{result.message}"
         end

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

@@ -0,0 +1,19 @@
+# A subscription is canceled.
+
+module Pay
+  module Braintree
+    module Webhooks
+      class SubscriptionCanceled
+        def call(event)
+          subscription = event.subscription
+          return if subscription.nil?
+
+          pay_subscription = Pay.subscription_model.find_by(processor: :braintree, processor_id: subscription.id)
+          return unless pay_subscription.present?
+
+          pay_subscription.update!(ends_at: Time.current, status: :canceled)
+        end
+      end
+    end
+  end
+end