pay 2.5.0 → 2.6.4

data/lib/pay/fake_processor/billable.rb

@@ -0,0 +1,60 @@
+module Pay
+  module FakeProcessor
+    class Billable
+      attr_reader :billable
+
+      delegate :processor_id,
+        :processor_id?,
+        :email,
+        :customer_name,
+        :card_token,
+        to: :billable
+
+      def initialize(billable)
+        @billable = billable
+      end
+
+      def customer
+        billable
+      end
+
+      def charge(amount, options = {})
+        billable.charges.create(
+          processor: :fake_processor,
+          processor_id: rand(100_000_000),
+          amount: amount,
+          card_type: :fake,
+          card_last4: 1234,
+          card_exp_month: Date.today.month,
+          card_exp_year: Date.today.year
+        )
+      end
+
+      def subscribe(name: Pay.default_product_name, plan: Pay.default_plan_name, **options)
+        subscription = OpenStruct.new id: rand(1_000_000)
+        billable.create_pay_subscription(subscription, :fake_processor, name, plan, status: :active, quantity: options.fetch(:quantity, 1))
+      end
+
+      def update_card(payment_method_id)
+        billable.update(
+          card_type: :fake,
+          card_last4: 1234,
+          card_exp_month: Date.today.month,
+          card_exp_year: Date.today.year
+        )
+      end
+
+      def update_email!
+        # pass
+      end
+
+      def processor_subscription(subscription_id, options = {})
+        billable.subscriptions.find_by(processor: :fake_processor, processor_id: subscription_id)
+      end
+
+      def trial_end_date(subscription)
+        Date.today
+      end
+    end
+  end
+end

data/lib/pay/fake_processor/charge.rb

@@ -0,0 +1,21 @@
+module Pay
+  module FakeProcessor
+    class Charge
+      attr_reader :pay_charge
+
+      delegate :processor_id, :owner, to: :pay_charge
+
+      def initialize(pay_charge)
+        @pay_charge = pay_charge
+      end
+
+      def charge
+        pay_charge
+      end
+
+      def refund!(amount_to_refund)
+        pay_charge.update(amount_refunded: amount_to_refund)
+      end
+    end
+  end
+end

data/lib/pay/fake_processor/error.rb

@@ -0,0 +1,6 @@
+module Pay
+  module FakeProcessor
+    class Error < Pay::Error
+    end
+  end
+end

data/lib/pay/fake_processor/subscription.rb

@@ -0,0 +1,55 @@
+module Pay
+  module FakeProcessor
+    class Subscription
+      attr_reader :pay_subscription
+
+      delegate :canceled?,
+        :ends_at,
+        :on_trial?,
+        :owner,
+        :processor_subscription,
+        :processor_id,
+        :prorate,
+        :processor_plan,
+        :quantity?,
+        :quantity,
+        to: :pay_subscription
+
+      def initialize(pay_subscription)
+        @pay_subscription = pay_subscription
+      end
+
+      def cancel
+        pay_subscription.update(ends_at: Time.current.end_of_month)
+      end
+
+      def cancel_now!
+        pay_subscription.update(ends_at: Time.current, status: :canceled)
+      end
+
+      def on_grace_period?
+        canceled? && Time.zone.now < ends_at
+      end
+
+      def paused?
+        false
+      end
+
+      def pause
+        raise NotImplementedError, "FakeProcessor does not support pausing subscriptions"
+      end
+
+      def resume
+        unless on_grace_period?
+          raise StandardError, "You can only resume subscriptions within their grace period."
+        end
+
+        pay_subscription.update(ends_at: nil, status: :active)
+      end
+
+      def swap(plan)
+        pay_subscription.update(processor_plan: plan)
+      end
+    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,77 @@
 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 :active?,
+        :canceled?,
+        :ends_at,
+        :name,
+        :on_trial?,
+        :owner,
+        :paddle_paused_from,
+        :processor_id,
+        :processor_plan,
+        :processor_subscription,
+        :prorate,
+        :prorate?,
+        :quantity,
+        :quantity?,
+        :trial_ends_at,
+        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)