pay 7.3.0 → 11.2.2

data/lib/pay/fake_processor/charge.rb

@@ -1,21 +0,0 @@
-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

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

data/lib/pay/fake_processor/payment_method.rb

@@ -1,21 +0,0 @@
-module Pay
-  module FakeProcessor
-    class PaymentMethod
-      attr_reader :pay_payment_method
-
-      delegate :customer, :processor_id, to: :pay_payment_method
-
-      def initialize(pay_payment_method)
-        @pay_payment_method = pay_payment_method
-      end
-
-      # Sets payment method as default on Stripe
-      def make_default!
-      end
-
-      # Remove payment method
-      def detach
-      end
-    end
-  end
-end

data/lib/pay/fake_processor/subscription.rb

@@ -1,90 +0,0 @@
-module Pay
-  module FakeProcessor
-    class Subscription
-      attr_reader :pay_subscription
-
-      delegate :active?,
-        :canceled?,
-        :on_grace_period?,
-        :on_trial?,
-        :ends_at,
-        :ends_at?,
-        :owner,
-        :processor_subscription,
-        :processor_id,
-        :prorate,
-        :processor_plan,
-        :quantity?,
-        :quantity,
-        to: :pay_subscription
-
-      def initialize(pay_subscription)
-        @pay_subscription = pay_subscription
-      end
-
-      def subscription(**options)
-        pay_subscription
-      end
-
-      # With trial, sets end to trial end (mimicing Stripe)
-      # Without trial, sets can ends_at to end of month
-      def cancel(**options)
-        return if canceled?
-
-        if pay_subscription.on_trial?
-          pay_subscription.update(ends_at: pay_subscription.trial_ends_at)
-        else
-          pay_subscription.update(ends_at: Time.current.end_of_month)
-        end
-      end
-
-      def cancel_now!(**options)
-        return if canceled?
-
-        ends_at = Time.current
-        pay_subscription.update(
-          status: :canceled,
-          trial_ends_at: (ends_at if pay_subscription.trial_ends_at?),
-          ends_at: ends_at
-        )
-      end
-
-      def change_quantity(quantity, **options)
-        pay_subscription.update(quantity: quantity)
-      end
-
-      def on_grace_period?
-        ends_at? && ends_at > Time.current
-      end
-
-      def paused?
-        pay_subscription.status == "paused"
-      end
-
-      def pause
-        pay_subscription.update(status: :paused, trial_ends_at: Time.current)
-      end
-
-      def resumable?
-        on_grace_period? || paused?
-      end
-
-      def resume
-        unless resumable?
-          raise StandardError, "You can only resume subscriptions within their grace period."
-        end
-
-        pay_subscription.update(status: :active, trial_ends_at: nil, ends_at: nil)
-      end
-
-      def swap(plan, **options)
-        pay_subscription.update(processor_plan: plan, ends_at: nil, status: :active)
-      end
-
-      # Retries the latest invoice for a Past Due subscription
-      def retry_failed_payment
-        pay_subscription.update(status: :active)
-      end
-    end
-  end
-end

data/lib/pay/lemon_squeezy/billable.rb

@@ -1,90 +0,0 @@
-module Pay
-  module PaddleBilling
-    class Billable
-      attr_reader :pay_customer
-
-      delegate :processor_id,
-        :processor_id?,
-        :email,
-        :customer_name,
-        :card_token,
-        to: :pay_customer
-
-      def initialize(pay_customer)
-        @pay_customer = pay_customer
-      end
-
-      def customer_attributes
-        {email: email, name: customer_name}
-      end
-
-      # Retrieves a Paddle::Customer object
-      #
-      # Finds an existing Paddle::Customer if processor_id exists
-      # Creates a new Paddle::Customer using `email` and `customer_name` if empty processor_id
-      #
-      # Returns a Paddle::Customer object
-      def customer
-        if processor_id?
-          ::Paddle::Customer.retrieve(id: processor_id)
-        else
-          sc = ::Paddle::Customer.create(email: email, name: customer_name)
-          pay_customer.update!(processor_id: sc.id)
-          sc
-        end
-      rescue ::Paddle::Error => e
-        raise Pay::PaddleBilling::Error, e
-      end
-
-      # Syncs name and email to Paddle::Customer
-      # You can also pass in other attributes that will be merged into the default attributes
-      def update_customer!(**attributes)
-        customer unless processor_id?
-        attrs = customer_attributes.merge(attributes)
-        ::Paddle::Customer.update(id: processor_id, **attrs)
-      end
-
-      def charge(amount, options = {})
-        return Pay::Error unless options
-
-        items = options[:items]
-        opts = options.except(:items).merge(customer_id: processor_id)
-        transaction = ::Paddle::Transaction.create(items: items, **opts)
-
-        attrs = {
-          amount: transaction.details.totals.grand_total,
-          created_at: transaction.created_at,
-          currency: transaction.currency_code,
-          metadata: transaction.details.line_items&.first&.id
-        }
-
-        charge = pay_customer.charges.find_or_initialize_by(processor_id: transaction.id)
-        charge.update(attrs)
-        charge
-      rescue ::Paddle::Error => e
-        raise Pay::PaddleBilling::Error, e
-      end
-
-      def subscribe(name: Pay.default_product_name, plan: Pay.default_plan_name, **options)
-        # pass
-      end
-
-      # 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::PaddleBilling::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 = {})
-        ::Paddle::Subscription.retrieve(id: subscription_id, **options)
-      rescue ::Paddle::Error => e
-        raise Pay::PaddleBilling::Error, e
-      end
-    end
-  end
-end

data/lib/pay/lemon_squeezy/charge.rb

@@ -1,68 +0,0 @@
-module Pay
-  module PaddleBilling
-    class Charge
-      attr_reader :pay_charge
-
-      delegate :processor_id, :customer, to: :pay_charge
-
-      def initialize(pay_charge)
-        @pay_charge = pay_charge
-      end
-
-      def self.sync(charge_id, object: nil, try: 0, retries: 1)
-        # Skip loading the latest charge details from the API if we already have it
-        object ||= ::Paddle::Transaction.retrieve(id: charge_id)
-
-        # Ignore transactions that aren't completed
-        return unless object.status == "completed"
-
-        # Ignore charges without a Customer
-        return if object.customer_id.blank?
-
-        pay_customer = Pay::Customer.find_by(processor: :paddle_billing, processor_id: object.customer_id)
-        return unless pay_customer
-
-        # Ignore transactions that are payment method changes
-        # But update the customer's payment method
-        if object.origin == "subscription_payment_method_change"
-          Pay::PaddleBilling::PaymentMethod.sync(pay_customer: pay_customer, attributes: object.payments.first)
-          return
-        end
-
-        attrs = {
-          amount: object.details.totals.grand_total,
-          created_at: object.created_at,
-          currency: object.currency_code,
-          metadata: object.details.line_items&.first&.id,
-          subscription: pay_customer.subscriptions.find_by(processor_id: object.subscription_id)
-        }
-
-        if object.payment
-          case object.payment.method_details.type.downcase
-          when "card"
-            attrs[:payment_method_type] = "card"
-            attrs[:brand] = details.card.type
-            attrs[:exp_month] = details.card.expiry_month
-            attrs[:exp_year] = details.card.expiry_year
-            attrs[:last4] = details.card.last4
-          when "paypal"
-            attrs[:payment_method_type] = "paypal"
-          end
-
-          # Update customer's payment method
-          Pay::PaddleBilling::PaymentMethod.sync(pay_customer: pay_customer, attributes: object.payments.first)
-        end
-
-        # Update or create the charge
-        if (pay_charge = pay_customer.charges.find_by(processor_id: object.id))
-          pay_charge.with_lock do
-            pay_charge.update!(attrs)
-          end
-          pay_charge
-        else
-          pay_customer.charges.create!(attrs.merge(processor_id: object.id))
-        end
-      end
-    end
-  end
-end

data/lib/pay/lemon_squeezy/error.rb

@@ -1,7 +0,0 @@
-module Pay
-  module PaddleBilling
-    class Error < Pay::Error
-      delegate :message, to: :cause
-    end
-  end
-end

data/lib/pay/lemon_squeezy/payment_method.rb

@@ -1,40 +0,0 @@
-module Pay
-  module PaddleBilling
-    class PaymentMethod
-      attr_reader :pay_payment_method
-
-      delegate :customer, :processor_id, to: :pay_payment_method
-
-      def self.sync(pay_customer:, attributes:)
-        details = attributes.method_details
-        attrs = {
-          type: details.type.downcase
-        }
-
-        case details.type.downcase
-        when "card"
-          attrs[:brand] = details.card.type
-          attrs[:last4] = details.card.last4
-          attrs[:exp_month] = details.card.expiry_month
-          attrs[:exp_year] = details.card.expiry_year
-        end
-
-        payment_method = pay_customer.payment_methods.find_or_initialize_by(processor_id: attributes.stored_payment_method_id)
-        payment_method.update!(attrs)
-        payment_method
-      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
-  end
-end

data/lib/pay/lemon_squeezy/subscription.rb

@@ -1,185 +0,0 @@
-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
-
-      def self.sync_from_transaction(transaction_id)
-        transaction = ::Paddle::Transaction.retrieve(id: transaction_id)
-        sync(transaction.subscription_id) if transaction.subscription_id
-      end
-
-      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 ||= ::Paddle::Subscription.retrieve(id: subscription_id)
-
-        pay_customer = Pay::Customer.find_by(processor: :paddle_billing, processor_id: object.customer_id)
-        return unless pay_customer
-
-        attributes = {
-          current_period_end: object.current_billing_period&.ends_at,
-          current_period_start: object.current_billing_period&.starts_at,
-          ends_at: (object.canceled_at ? Time.parse(object.canceled_at) : nil),
-          metadata: object.custom_data,
-          paddle_cancel_url: object.management_urls&.cancel,
-          paddle_update_url: object.management_urls&.update_payment_method,
-          pause_starts_at: (object.paused_at ? Time.parse(object.paused_at) : nil),
-          status: object.status
-        }
-
-        if object.items&.first
-          item = object.items.first
-          attributes[:processor_plan] = item.price.id
-          attributes[:quantity] = item.quantity
-        end
-
-        case attributes[:status]
-        when "canceled"
-          # Remove payment methods since customer cannot be reused after cancelling
-          Pay::PaymentMethod.where(customer_id: object.customer_id).destroy_all
-        when "trialing"
-          attributes[:trial_ends_at] = Time.parse(object.next_billed_at)
-        when "paused"
-          attributes[:pause_starts_at] = Time.parse(object.paused_at)
-        end
-
-        case object.scheduled_change&.action
-        when "cancel"
-          attributes[:ends_at] = Time.parse(object.scheduled_change.effective_at)
-        when "pause"
-          attributes[:pause_starts_at] = Time.parse(object.scheduled_change.effective_at)
-        when "resume"
-          attributes[:pause_resumes_at] = Time.parse(object.scheduled_change.effective_at)
-        end
-
-        # Update or create the subscription
-        if (pay_subscription = pay_customer.subscriptions.find_by(processor_id: subscription_id))
-          pay_subscription.with_lock do
-            pay_subscription.update!(attributes)
-          end
-          pay_subscription
-        else
-          pay_customer.subscriptions.create!(attributes.merge(name: name, processor_id: subscription_id))
-        end
-      end
-
-      def initialize(pay_subscription)
-        @pay_subscription = pay_subscription
-      end
-
-      def subscription(**options)
-        @paddle_billing_subscription ||= ::Paddle::Subscription.retrieve(id: processor_id, **options)
-      end
-
-      # Get a transaction to update payment method
-      def payment_method_transaction
-        ::Paddle::Subscription.get_transaction(id: processor_id)
-      end
-
-      # If a subscription is paused, cancel immediately
-      # Otherwise, cancel at period end
-      def cancel(**options)
-        return if canceled?
-
-        response = ::Paddle::Subscription.cancel(
-          id: processor_id,
-          effective_from: options.fetch(:effective_from, (paused? ? "immediately" : "next_billing_period"))
-        )
-        pay_subscription.update(
-          status: response.status,
-          ends_at: response.scheduled_change.effective_at
-        )
-      rescue ::Paddle::Error => e
-        raise Pay::PaddleBilling::Error, e
-      end
-
-      def cancel_now!(**options)
-        cancel(options.merge(effective_from: "immediately"))
-      rescue ::Paddle::Error => e
-        raise Pay::PaddleBilling::Error, e
-      end
-
-      def change_quantity(quantity, **options)
-        items = [{
-          price_id: processor_plan,
-          quantity: quantity
-        }]
-
-        ::Paddle::Subscription.update(id: processor_id, items: items, proration_billing_mode: "prorated_immediately")
-      rescue ::Paddle::Error => e
-        raise Pay::PaddleBilling::Error, e
-      end
-
-      # A subscription could be set to cancel or pause in the future
-      # It is considered on grace period until the cancel or pause time begins
-      def on_grace_period?
-        (canceled? && Time.current < ends_at) || (paused? && pause_starts_at? && Time.current < pause_starts_at)
-      end
-
-      def paused?
-        pay_subscription.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)
-      rescue ::Paddle::Error => e
-        raise Pay::PaddleBilling::Error, e
-      end
-
-      def resumable?
-        paused?
-      end
-
-      def resume
-        unless resumable?
-          raise StandardError, "You can only resume paused subscriptions."
-        end
-
-        # Paddle Billing API only allows "resuming" subscriptions when they are paused
-        # So cancel the scheduled change if it is in the future
-        if paused? && pause_starts_at? && Time.current < pause_starts_at
-          ::Paddle::Subscription.update(id: processor_id, scheduled_change: nil)
-        else
-          ::Paddle::Subscription.resume(id: processor_id, effective_from: "immediately")
-        end
-
-        pay_subscription.update(status: :active, pause_starts_at: nil)
-      rescue ::Paddle::Error => e
-        raise Pay::PaddleBilling::Error, e
-      end
-
-      def swap(plan, **options)
-        items = [{
-          price_id: plan,
-          quantity: quantity || 1
-        }]
-
-        ::Paddle::Subscription.update(id: processor_id, items: items, proration_billing_mode: "prorated_immediately")
-        pay_subscription.update(processor_plan: plan, ends_at: nil, status: :active)
-      end
-
-      # Retries the latest invoice for a Past Due subscription
-      def retry_failed_payment
-      end
-    end
-  end
-end

data/lib/pay/lemon_squeezy/webhooks/transaction_completed.rb

@@ -1,11 +0,0 @@
-module Pay
-  module PaddleBilling
-    module Webhooks
-      class TransactionCompleted
-        def call(event)
-          Pay::PaddleBilling::Charge.sync(event.id)
-        end
-      end
-    end
-  end
-end

data/lib/pay/paddle_billing/error.rb

@@ -1,7 +0,0 @@
-module Pay
-  module PaddleBilling
-    class Error < Pay::Error
-      delegate :message, to: :cause
-    end
-  end
-end

data/lib/pay/paddle_classic/error.rb

@@ -1,7 +0,0 @@
-module Pay
-  module PaddleClassic
-    class Error < Pay::Error
-      delegate :message, to: :cause
-    end
-  end
-end