pay 2.4.2 → 2.6.1

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

@@ -0,0 +1,24 @@
+# A subscription successfully moves to the next billing cycle. This will also occur when either a new transaction is created mid-cycle due to proration on an upgrade or a billing cycle is skipped due to the presence of a negative balance that covers the cost of the subscription.
+
+module Pay
+  module Braintree
+    module Webhooks
+      class SubscriptionChargedSuccessfully
+        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?
+
+          billable = pay_subscription.owner
+          charge = Pay::Braintree::Billable.new(billable).save_transaction(subscription.transactions.first)
+
+          if Pay.send_emails
+            Pay::UserMailer.with(billable: billable, charge: charge).receipt.deliver_later
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# A subscription successfully moves to the next billing cycle. This will also occur when either a new transaction is created mid-cycle due to proration on an upgrade or a billing cycle is skipped due to the presence of a negative balance that covers the cost of the subscription.
+
+module Pay
+  module Braintree
+    module Webhooks
+      class SubscriptionChargedUnsuccessfully
+        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?
+
+          # billable = pay_subscription.owner
+          # charge = Pay::Braintree::Billable.new(billable).save_transaction(subscription.transactions.first)
+
+          # if Pay.send_emails
+          #  Pay::UserMailer.with(billable: billable, charge: charge).receipt.deliver_later
+          # end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# A subscription reaches the specified number of billing cycles and expires.
+
+module Pay
+  module Braintree
+    module Webhooks
+      class SubscriptionExpired
+        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

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

@@ -0,0 +1,19 @@
+# A subscription's trial period ends.
+
+module Pay
+  module Braintree
+    module Webhooks
+      class SubscriptionTrialEnded
+        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(trial_ends_at: Time.zone.now)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# 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.
+
+module Pay
+  module Braintree
+    module Webhooks
+      class SubscriptionWentActive
+        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!(status: :active)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# 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.
+
+module Pay
+  module Braintree
+    module Webhooks
+      class SubscriptionWentPastDue
+        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!(status: :past_due)
+        end
+      end
+    end
+  end
+end

data/lib/pay/engine.rb

@@ -1,33 +1,10 @@
 # frozen_string_literal: true
 
-# rubocop:disable Lint/HandleExceptions
-begin
-  require "braintree"
-rescue LoadError
-end
-
-begin
-  require "stripe"
-  require "stripe_event"
-rescue LoadError
-end
-
-begin
-  require "paddle_pay"
-rescue LoadError
-end
-# rubocop:enable Lint/HandleExceptions
-
 module Pay
   class Engine < ::Rails::Engine
     engine_name "pay"
 
     initializer "pay.processors" do |app|
-      # Include processor backends
-      require "pay/stripe" if defined? ::Stripe
-      require "pay/braintree" if defined? ::Braintree
-      require "pay/paddle" if defined? ::PaddlePay
-
       if Pay.automount_routes
         app.routes.append do
           mount Pay::Engine, at: Pay.routes_path, as: "pay"

data/lib/pay/errors.rb

@@ -26,48 +26,4 @@ module Pay
       I18n.t("errors.invalid_payment")
     end
   end
-
-  module Braintree
-    class Error < Error
-      def message
-        result.message
-      end
-    end
-
-    class AuthorizationError < Braintree::Error
-      def message
-        I18n.t("errors.braintree.authorization")
-      end
-    end
-  end
-
-  module Stripe
-    class Error < Error
-      def message
-        I18n.t("errors.stripe.#{result.code}", default: result.message)
-      end
-    end
-  end
-
-  module Paddle
-    class Error < Error
-      def message
-        I18n.t("errors.paddle.#{result.code}", default: result.message)
-      end
-    end
-  end
-
-  class BraintreeError < Braintree::Error
-    def message
-      ActiveSupport::Deprecation.warn("Pay::BraintreeError is deprecated. Instead, use `Pay::Braintree::Error`.")
-      super
-    end
-  end
-
-  class BraintreeAuthorizationError < BraintreeError
-    def message
-      ActiveSupport::Deprecation.warn("Pay::BraintreeAuthorizationError is deprecated. Instead, use `Pay::Braintree::AuthorizationError`.")
-      I18n.t("errors.braintree.authorization")
-    end
-  end
 end

data/lib/pay/paddle.rb

@@ -1,38 +1,52 @@
-require "pay/env"
-require "pay/paddle/billable"
-require "pay/paddle/charge"
-require "pay/paddle/subscription"
-require "pay/paddle/webhooks"
-
 module Pay
   module Paddle
-    include Env
+    autoload :Billable, "pay/paddle/billable"
+    autoload :Charge, "pay/paddle/charge"
+    autoload :Subscription, "pay/paddle/subscription"
+    autoload :Error, "pay/paddle/error"
+
+    module Webhooks
+      autoload :SignatureVerifier, "pay/paddle/webhooks/signature_verifier"
+      autoload :SubscriptionCreated, "pay/paddle/webhooks/subscription_created"
+      autoload :SubscriptionCancelled, "pay/paddle/webhooks/subscription_cancelled"
+      autoload :SubscriptionPaymentRefunded, "pay/paddle/webhooks/subscription_payment_refunded"
+      autoload :SubscriptionPaymentSucceeded, "pay/paddle/webhooks/subscription_payment_succeeded"
+      autoload :SubscriptionUpdated, "pay/paddle/webhooks/subscription_updated"
+    end
 
-    extend self
+    extend Env
 
-    def setup
+    def self.setup
       ::PaddlePay.config.vendor_id = vendor_id
       ::PaddlePay.config.vendor_auth_code = vendor_auth_code
 
-      Pay.charge_model.include Pay::Paddle::Charge
-      Pay.subscription_model.include Pay::Paddle::Subscription
-      Pay.billable_models.each { |model| model.include Pay::Paddle::Billable }
+      configure_webhooks
     end
 
-    def vendor_id
+    def self.vendor_id
       find_value_by_name(:paddle, :vendor_id)
     end
 
-    def vendor_auth_code
+    def self.vendor_auth_code
       find_value_by_name(:paddle, :vendor_auth_code)
     end
 
-    def public_key_base64
+    def self.public_key_base64
       find_value_by_name(:paddle, :public_key_base64)
     end
 
-    def passthrough(owner:, **options)
+    def self.passthrough(owner:, **options)
       options.merge(owner_sgid: owner.to_sgid.to_s).to_json
     end
+
+    def self.configure_webhooks
+      Pay::Webhooks.configure do |events|
+        events.subscribe "paddle.subscription_created", Pay::Paddle::Webhooks::SubscriptionCreated.new
+        events.subscribe "paddle.subscription_updated", Pay::Paddle::Webhooks::SubscriptionUpdated.new
+        events.subscribe "paddle.subscription_cancelled", Pay::Paddle::Webhooks::SubscriptionCancelled.new
+        events.subscribe "paddle.subscription_payment_succeeded", Pay::Paddle::Webhooks::SubscriptionPaymentSucceeded.new
+        events.subscribe "paddle.subscription_payment_refunded", Pay::Paddle::Webhooks::SubscriptionPaymentRefunded.new
+      end
+    end
   end
 end

data/lib/pay/paddle/billable.rb

@@ -1,27 +1,32 @@
 module Pay
   module Paddle
-    module Billable
-      extend ActiveSupport::Concern
+    class Billable
+      attr_reader :billable
 
-      included do
-        scope :paddle, -> { where(processor: :paddle) }
+      delegate :processor_id,
+        :processor_id?,
+        :email,
+        :customer_name,
+        :card_token,
+        to: :billable
+
+      def initialize(billable)
+        @billable = billable
       end
 
-      def paddle_customer
+      def customer
         # pass
       end
 
-      def create_paddle_charge(amount, options = {})
+      def charge(amount, options = {})
+        subscription = billable.subscription
         return unless subscription.processor_id
         raise Pay::Error, "A charge_name is required to create a one-time charge" if options[:charge_name].nil?
         response = PaddlePay::Subscription::Charge.create(subscription.processor_id, amount.to_f / 100, options[:charge_name], options)
-        charge = charges.find_or_initialize_by(
-          processor: :paddle,
-          processor_id: response[:invoice_id]
-        )
+        charge = billable.charges.find_or_initialize_by(processor: :paddle, processor_id: response[:invoice_id])
         charge.update(
           amount: Integer(response[:amount].to_f * 100),
-          card_type: subscription.processor_subscription.payment_information[:payment_method],
+          card_type: processor_subscription(subscription.processor_id).payment_information[:payment_method],
           paddle_receipt_url: response[:receipt_url],
           created_at: Time.zone.parse(response[:payment_date])
         )
@@ -30,46 +35,45 @@ module Pay
         raise Pay::Paddle::Error, e
       end
 
-      def create_paddle_subscription(name, plan, options = {})
+      def subscribe(name: Pay.default_product_name, plan: Pay.default_plan_name, **options)
         # pass
       end
 
-      def update_paddle_card(token)
+      def update_card(token)
         sync_payment_information_from_paddle
       end
 
-      def update_paddle_email!
+      def update_email!
         # pass
       end
 
-      def paddle_trial_end_date(subscription)
+      def trial_end_date(subscription)
         return unless subscription.state == "trialing"
         Time.zone.parse(subscription.next_payment[:date]).end_of_day
       end
 
-      def paddle_subscription(subscription_id, options = {})
+      def processor_subscription(subscription_id, options = {})
         hash = PaddlePay::Subscription::User.list({subscription_id: subscription_id}, options).try(:first)
         OpenStruct.new(hash)
       rescue ::PaddlePay::PaddlePayError => e
         raise Pay::Paddle::Error, e
       end
 
-      def paddle_invoice!(options = {})
+      def invoice!(options = {})
         # pass
       end
 
-      def paddle_upcoming_invoice
+      def upcoming_invoice
         # pass
       end
 
-      def sync_payment_information_from_paddle
-        payment_information = paddle_payment_information(subscription.processor_id)
-        update!(payment_information) unless payment_information.empty?
+      def sync_payment_information
+        billable.update!(payment_information(billable.subscription.processor_id))
       rescue ::PaddlePay::PaddlePayError => e
         raise Pay::Paddle::Error, e
       end
 
-      def paddle_payment_information(subscription_id)
+      def payment_information(subscription_id)
         subscription_user = PaddlePay::Subscription::User.list({subscription_id: subscription_id}).try(:first)
         payment_information = subscription_user ? subscription_user[:payment_information] : nil
         return {} if payment_information.nil?

data/lib/pay/paddle/charge.rb

@@ -1,19 +1,15 @@
 module Pay
   module Paddle
-    module Charge
-      extend ActiveSupport::Concern
+    class Charge
+      attr_reader :pay_charge
 
-      included do
-        scope :paddle, -> { where(processor: :paddle) }
+      delegate :processor_id, :owner, to: :pay_charge
 
-        store_accessor :data, :paddle_receipt_url
+      def initialize(pay_charge)
+        @pay_charge = pay_charge
       end
 
-      def paddle?
-        processor == "paddle"
-      end
-
-      def paddle_charge
+      def charge
         return unless owner.subscription
         payments = PaddlePay::Subscription::Payment.list({subscription_id: owner.subscription.processor_id})
         charges = payments.select { |p| p[:id].to_s == processor_id }
@@ -22,12 +18,12 @@ module Pay
         raise Pay::Paddle::Error, e
       end
 
-      def paddle_refund!(amount_to_refund)
+      def refund!(amount_to_refund)
         return unless owner.subscription
         payments = PaddlePay::Subscription::Payment.list({subscription_id: owner.subscription.processor_id, is_paid: 1})
         if payments.count > 0
           PaddlePay::Subscription::Payment.refund(payments.last[:id], {amount: amount_to_refund})
-          update(amount_refunded: amount_to_refund)
+          pay_charge.update(amount_refunded: amount_to_refund)
         else
           raise Error, "Payment not found"
         end

data/lib/pay/paddle/error.rb

@@ -0,0 +1,9 @@
+module Pay
+  module Paddle
+    class Error < Pay::Error
+      def message
+        I18n.t("errors.paddle.#{result.code}", default: result.message)
+      end
+    end
+  end
+end

data/lib/pay/paddle/subscription.rb

@@ -1,62 +1,73 @@
 module Pay
   module Paddle
-    module Subscription
-      extend ActiveSupport::Concern
+    class Subscription
+      attr_reader :pay_subscription
 
-      included do
-        store_accessor :data, :paddle_update_url
-        store_accessor :data, :paddle_cancel_url
-        store_accessor :data, :paddle_paused_from
+      delegate :canceled?,
+        :ends_at,
+        :on_trial?,
+        :owner,
+        :paddle_paused_from,
+        :processor_id,
+        :processor_plan,
+        :processor_subscription,
+        :prorate,
+        :quantity,
+        :quantity?,
+        to: :pay_subscription
+
+      def initialize(pay_subscription)
+        @pay_subscription = pay_subscription
       end
 
-      def paddle_cancel
+      def cancel
         subscription = processor_subscription
         PaddlePay::Subscription::User.cancel(processor_id)
         if on_trial?
-          update(status: :canceled, ends_at: trial_ends_at)
+          pay_subscription.update(status: :canceled, ends_at: trial_ends_at)
         else
-          update(status: :canceled, ends_at: Time.zone.parse(subscription.next_payment[:date]))
+          pay_subscription.update(status: :canceled, ends_at: Time.zone.parse(subscription.next_payment[:date]))
         end
       rescue ::PaddlePay::PaddlePayError => e
         raise Pay::Paddle::Error, e
       end
 
-      def paddle_cancel_now!
+      def cancel_now!
         PaddlePay::Subscription::User.cancel(processor_id)
-        update(status: :canceled, ends_at: Time.zone.now)
+        pay_subscription.update(status: :canceled, ends_at: Time.zone.now)
       rescue ::PaddlePay::PaddlePayError => e
         raise Pay::Paddle::Error, e
       end
 
-      def paddle_on_grace_period?
+      def on_grace_period?
         canceled? && Time.zone.now < ends_at || paused? && Time.zone.now < paddle_paused_from
       end
 
-      def paddle_paused?
+      def paused?
         paddle_paused_from.present?
       end
 
-      def paddle_pause
+      def pause
         attributes = {pause: true}
         response = PaddlePay::Subscription::User.update(processor_id, attributes)
-        update(paddle_paused_from: Time.zone.parse(response[:next_payment][:date]))
+        pay_subscription.update(paddle_paused_from: Time.zone.parse(response[:next_payment][:date]))
       rescue ::PaddlePay::PaddlePayError => e
         raise Pay::Paddle::Error, e
       end
 
-      def paddle_resume
+      def resume
         unless paused?
           raise StandardError, "You can only resume paused subscriptions."
         end
 
         attributes = {pause: false}
         PaddlePay::Subscription::User.update(processor_id, attributes)
-        update(status: :active, paddle_paused_from: nil)
+        pay_subscription.update(status: :active, paddle_paused_from: nil)
       rescue ::PaddlePay::PaddlePayError => e
         raise Pay::Paddle::Error, e
       end
 
-      def paddle_swap(plan)
+      def swap(plan)
         attributes = {plan_id: plan, prorate: prorate}
         attributes[:quantity] = quantity if quantity?
         PaddlePay::Subscription::User.update(processor_id, attributes)