pay 7.2.1 → 8.0.0

data/{lib → app/models}/pay/paddle_billing/subscription.rb

@@ -1,27 +1,6 @@
 module Pay
   module PaddleBilling
-    class Subscription
-      attr_reader :pay_subscription
-
-      delegate :active?,
-        :canceled?,
-        :on_grace_period?,
-        :on_trial?,
-        :ends_at,
-        :name,
-        :owner,
-        :pause_starts_at,
-        :pause_starts_at?,
-        :processor_id,
-        :processor_plan,
-        :processor_subscription,
-        :prorate,
-        :prorate?,
-        :quantity,
-        :quantity?,
-        :trial_ends_at,
-        to: :pay_subscription
-
+    class Subscription < Pay::Subscription
       def self.sync_from_transaction(transaction_id)
         transaction = ::Paddle::Transaction.retrieve(id: transaction_id)
         sync(transaction.subscription_id) if transaction.subscription_id
@@ -85,12 +64,8 @@ module Pay
         end
       end
 
-      def initialize(pay_subscription)
-        @pay_subscription = pay_subscription
-      end
-
-      def subscription(**options)
-        @paddle_billing_subscription ||= ::Paddle::Subscription.retrieve(id: processor_id, **options)
+      def api_record(**options)
+        @api_record ||= ::Paddle::Subscription.retrieve(id: processor_id, **options)
       end
 
       # Get a transaction to update payment method
@@ -107,7 +82,7 @@ module Pay
           id: processor_id,
           effective_from: options.fetch(:effective_from, (paused? ? "immediately" : "next_billing_period"))
         )
-        pay_subscription.update(
+        update(
           status: response.status,
           ends_at: response.scheduled_change&.effective_at || Time.current
         )
@@ -128,6 +103,7 @@ module Pay
         }]
 
         ::Paddle::Subscription.update(id: processor_id, items: items, proration_billing_mode: "prorated_immediately")
+        update(quantity: quantity)
       rescue ::Paddle::Error => e
         raise Pay::PaddleBilling::Error, e
       end
@@ -139,12 +115,12 @@ module Pay
       end
 
       def paused?
-        pay_subscription.status == "paused"
+        status == "paused"
       end
 
       def pause
         response = ::Paddle::Subscription.pause(id: processor_id)
-        pay_subscription.update!(status: :paused, pause_starts_at: response.scheduled_change.effective_at)
+        update!(status: :paused, pause_starts_at: response.scheduled_change.effective_at)
       rescue ::Paddle::Error => e
         raise Pay::PaddleBilling::Error, e
       end
@@ -166,7 +142,7 @@ module Pay
           ::Paddle::Subscription.resume(id: processor_id, effective_from: "immediately")
         end
 
-        pay_subscription.update(status: :active, pause_starts_at: nil)
+        update(ends_at: nil, status: :active, pause_starts_at: nil)
       rescue ::Paddle::Error => e
         raise Pay::PaddleBilling::Error, e
       end
@@ -178,7 +154,7 @@ module Pay
         }]
 
         ::Paddle::Subscription.update(id: processor_id, items: items, proration_billing_mode: "prorated_immediately")
-        pay_subscription.update(processor_plan: plan, ends_at: nil, status: :active)
+        update(processor_plan: plan, ends_at: nil, status: :active)
       end
 
       # Retries the latest invoice for a Past Due subscription

data/{lib → app/models}/pay/paddle_classic/charge.rb

@@ -1,33 +1,28 @@
 module Pay
   module PaddleClassic
-    class Charge
-      attr_reader :pay_charge
+    class Charge < Pay::Charge
+      store_accessor :data, :paddle_receipt_url
 
-      delegate :processor_id, :customer, to: :pay_charge
-
-      def initialize(pay_charge)
-        @pay_charge = pay_charge
-      end
-
-      def charge
+      def api_record
         return unless customer.subscription
+
         payments = PaddleClassic.client.payments.list(subscription_id: customer.subscription.processor_id)
         charges = payments.data.select { |p| p[:id].to_s == processor_id }
         charges.try(:first)
-      rescue ::Paddle::Error => e
+      rescue ::Paddle::Classic::Error => e
         raise Pay::PaddleClassic::Error, e
       end
 
-      def refund!(amount_to_refund)
+      def refund!(amount_to_refund = nil)
         return unless customer.subscription
+        amount_to_refund ||= amount
+
         payments = PaddleClassic.client.payments.list(subscription_id: customer.subscription.processor_id, is_paid: 1)
-        if payments.total > 0
-          PaddleClassic.client.payments.refund(order_id: payments.data.last[:id], amount: amount_to_refund)
-          pay_charge.update(amount_refunded: amount_to_refund)
-        else
-          raise Error, "Payment not found"
-        end
-      rescue ::Paddle::Error => e
+        raise Error, "Payment not found" unless payments.total > 0
+
+        PaddleClassic.client.payments.refund(order_id: payments.data.last[:id], amount: amount_to_refund)
+        update(amount_refunded: amount_to_refund)
+      rescue ::Paddle::Classic::Error => e
         raise Pay::PaddleClassic::Error, e
       end
     end

data/{lib/pay/paddle_classic/billable.rb → app/models/pay/paddle_classic/customer.rb}

@@ -1,29 +1,18 @@
 module Pay
   module PaddleClassic
-    class Billable
-      attr_reader :pay_customer
+    class Customer < Pay::Customer
+      has_many :charges, dependent: :destroy, class_name: "Pay::PaddleClassic::Charge"
+      has_many :subscriptions, dependent: :destroy, class_name: "Pay::PaddleClassic::Subscription"
+      has_many :payment_methods, dependent: :destroy, class_name: "Pay::PaddleClassic::PaymentMethod"
+      has_one :default_payment_method, -> { where(default: true) }, class_name: "Pay::PaddleClassic::PaymentMethod"
 
-      delegate :processor_id,
-        :processor_id?,
-        :email,
-        :customer_name,
-        :card_token,
-        to: :pay_customer
-
-      def initialize(pay_customer)
-        @pay_customer = pay_customer
-      end
-
-      def customer
-        # pass
+      def api_record
       end
 
-      def update_customer!
-        # pass
+      def update_api_record
       end
 
       def charge(amount, options = {})
-        subscription = pay_customer.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?
 
@@ -38,7 +27,7 @@ module Pay
         # Lookup subscription payment method details
         attributes.merge! Pay::PaddleClassic::PaymentMethod.payment_method_details_for(subscription_id: subscription.processor_id)
 
-        charge = pay_customer.charges.find_or_initialize_by(processor_id: response[:invoice_id])
+        charge = charges.find_or_initialize_by(processor_id: response[:invoice_id])
         charge.update(attributes)
         charge
       rescue ::Paddle::Error => e
@@ -52,18 +41,7 @@ module Pay
       # Paddle does not use payment method tokens. The method signature has it here
       # to have a uniform API with the other payment processors.
       def add_payment_method(token = nil, default: true)
-        Pay::PaddleClassic::PaymentMethod.sync(pay_customer: pay_customer)
-      end
-
-      def trial_end_date(subscription)
-        return unless subscription.state == "trialing"
-        Time.zone.parse(subscription.next_payment[:date]).end_of_day
-      end
-
-      def processor_subscription(subscription_id, options = {})
-        PaddleClassic.client.users.list(subscription_id: subscription_id).data.try(:first)
-      rescue ::Paddle::Error => e
-        raise Pay::PaddleClassic::Error, e
+        Pay::PaddleClassic::PaymentMethod.sync(pay_customer: self)
       end
     end
   end

data/{lib → app/models}/pay/paddle_classic/payment_method.rb

@@ -1,10 +1,6 @@
 module Pay
   module PaddleClassic
-    class PaymentMethod
-      attr_reader :pay_payment_method
-
-      delegate :customer, :processor_id, to: :pay_payment_method
-
+    class PaymentMethod < Pay::PaymentMethod
       # Paddle doesn't provide PaymentMethod IDs, so we have to lookup via the Customer
       def self.sync(pay_customer:, attributes: nil)
         return unless pay_customer.subscription
@@ -44,15 +40,9 @@ module Pay
         end
       end
 
-      def initialize(pay_payment_method)
-        @pay_payment_method = pay_payment_method
-      end
-
-      # Sets payment method as default
       def make_default!
       end
 
-      # Remove payment method
       def detach
       end
     end

data/{lib → app/models}/pay/paddle_classic/subscription.rb

@@ -1,27 +1,6 @@
 module Pay
   module PaddleClassic
-    class Subscription
-      attr_reader :pay_subscription
-
-      delegate :active?,
-        :canceled?,
-        :on_grace_period?,
-        :on_trial?,
-        :ends_at,
-        :name,
-        :owner,
-        :pause_starts_at,
-        :pause_starts_at?,
-        :processor_id,
-        :processor_plan,
-        :processor_subscription,
-        :prorate,
-        :prorate?,
-        :quantity,
-        :quantity?,
-        :trial_ends_at,
-        to: :pay_subscription
-
+    class Subscription < Pay::Subscription
       def self.sync(subscription_id, object: nil, name: Pay.default_product_name)
         # Passthrough is not return from this API, so we can't use that
         object ||= PaddleClassic.client.users.list(subscription_id: subscription_id).data.try(:first)
@@ -68,11 +47,7 @@ module Pay
         end
       end
 
-      def initialize(pay_subscription)
-        @pay_subscription = pay_subscription
-      end
-
-      def subscription(**options)
+      def api_record(**options)
         PaddleClassic.client.users.list(subscription_id: processor_id).data.try(:first)
       rescue ::Paddle::Error => e
         raise Pay::PaddleClassic::Error, e
@@ -87,17 +62,17 @@ module Pay
         elsif paused?
           pause_starts_at
         else
-          Time.parse(processor_subscription.next_payment.date)
+          Time.parse(api_record.next_payment.date)
         end
 
         PaddleClassic.client.users.cancel(subscription_id: processor_id)
-        pay_subscription.update(
+        update(
           status: (ends_at.future? ? :active : :canceled),
           ends_at: ends_at
         )
 
         # Remove payment methods since customer cannot be reused after cancelling
-        Pay::PaymentMethod.where(customer_id: pay_subscription.customer_id).destroy_all
+        Pay::PaymentMethod.where(customer_id: customer_id).destroy_all
       rescue ::Paddle::Error => e
         raise Pay::PaddleClassic::Error, e
       end
@@ -106,10 +81,10 @@ module Pay
         return if canceled?
 
         PaddleClassic.client.users.cancel(subscription_id: processor_id)
-        pay_subscription.update(status: :canceled, ends_at: Time.current)
+        update(status: :canceled, ends_at: Time.current)
 
         # Remove payment methods since customer cannot be reused after cancelling
-        Pay::PaymentMethod.where(customer_id: pay_subscription.customer_id).destroy_all
+        Pay::PaymentMethod.where(customer_id: customer_id).destroy_all
       rescue ::Paddle::Error => e
         raise Pay::PaddleClassic::Error, e
       end
@@ -125,12 +100,12 @@ module Pay
       end
 
       def paused?
-        pay_subscription.status == "paused"
+        status == "paused"
       end
 
       def pause
         response = PaddleClassic.client.users.pause(subscription_id: processor_id)
-        pay_subscription.update(status: :paused, pause_starts_at: Time.zone.parse(response.dig(:next_payment, :date)))
+        update(status: :paused, pause_starts_at: Time.zone.parse(response.dig(:next_payment, :date)))
       rescue ::Paddle::Error => e
         raise Pay::PaddleClassic::Error, e
       end
@@ -145,7 +120,7 @@ module Pay
         end
 
         PaddleClassic.client.users.unpause(subscription_id: processor_id)
-        pay_subscription.update(status: :active, pause_starts_at: nil)
+        update(ends_at: nil, status: :active, pause_starts_at: nil)
       rescue ::Paddle::Error => e
         raise Pay::PaddleClassic::Error, e
       end
@@ -157,7 +132,7 @@ module Pay
         attributes[:quantity] = quantity if quantity?
         PaddleClassic.client.users.update(subscription_id: processor_id, **attributes)
 
-        pay_subscription.update(processor_plan: plan, ends_at: nil, status: :active)
+        update(processor_plan: plan, ends_at: nil, status: :active)
       rescue ::Paddle::Error => e
         raise Pay::PaddleClassic::Error, e
       end

data/app/models/pay/payment_method.rb

@@ -1,7 +1,5 @@
 module Pay
   class PaymentMethod < Pay::ApplicationRecord
-    self.inheritance_column = nil
-
     belongs_to :customer
 
     store_accessor :data, :brand # Visa, Mastercard, Discover, PayPal
@@ -12,9 +10,6 @@ module Pay
     store_accessor :data, :username
     store_accessor :data, :bank
 
-    # Aliases to share PaymentMethodAttributes
-    alias_attribute :payment_method_type, :type
-
     validates :processor_id, presence: true, uniqueness: {scope: :customer_id, case_sensitive: true}
 
     def self.find_by_processor_and_id(processor, processor_id)

data/{lib → app/models}/pay/stripe/charge.rb

@@ -1,16 +1,7 @@
 module Pay
   module Stripe
-    class Charge
-      attr_reader :pay_charge
-
-      delegate :amount,
-        :amount_captured,
-        :invoice_id,
-        :line_items,
-        :payment_intent_id,
-        :processor_id,
-        :stripe_account,
-        to: :pay_charge
+    class Charge < Pay::Charge
+      store_accessor :data, :stripe_receipt_url
 
       def self.sync(charge_id, object: nil, stripe_account: nil, try: 0, retries: 1)
         # Skip loading the latest charge details from the API if we already have it
@@ -108,11 +99,7 @@ module Pay
         end
       end
 
-      def initialize(pay_charge)
-        @pay_charge = pay_charge
-      end
-
-      def charge
+      def api_record
         ::Stripe::Charge.retrieve({id: processor_id, expand: ["customer", "invoice.subscription"]}, stripe_options)
       rescue ::Stripe::StripeError => e
         raise Pay::Stripe::Error, e
@@ -128,6 +115,8 @@ module Pay
       # refund!(5_00)
       # refund!(5_00, refund_application_fee: true)
       def refund!(amount_to_refund, **options)
+        amount_to_refund ||= amount
+
         if invoice_id.present?
           description = options.delete(:description) || I18n.t("pay.refund")
           lines = [{type: :custom_line_item, description: description, quantity: 1, unit_amount: amount_to_refund}]
@@ -135,7 +124,7 @@ module Pay
         else
           ::Stripe::Refund.create(options.merge(charge: processor_id, amount: amount_to_refund), stripe_options)
         end
-        pay_charge.update!(amount_refunded: pay_charge.amount_refunded + amount_to_refund)
+        update!(amount_refunded: amount_refunded + amount_to_refund)
       rescue ::Stripe::StripeError => e
         raise Pay::Stripe::Error, e
       end
@@ -148,11 +137,6 @@ module Pay
         raise Pay::Stripe::Error, e
       end
 
-      def credit_notes(**options)
-        raise Pay::Stripe::Error, "no Stripe invoice_id on Pay::Charge" if invoice_id.blank?
-        ::Stripe::CreditNote.list({invoice: invoice_id}.merge(options), stripe_options)
-      end
-
       # https://stripe.com/docs/payments/capture-later
       #
       # capture