pay 2.7.0 → 3.0.1

data/lib/pay/paddle/billable.rb

@@ -1,17 +1,17 @@
 module Pay
   module Paddle
     class Billable
-      attr_reader :billable
+      attr_reader :pay_customer
 
       delegate :processor_id,
         :processor_id?,
         :email,
         :customer_name,
         :card_token,
-        to: :billable
+        to: :pay_customer
 
-      def initialize(billable)
-        @billable = billable
+      def initialize(pay_customer)
+        @pay_customer = pay_customer
       end
 
       def customer
@@ -19,17 +19,23 @@ module Pay
       end
 
       def charge(amount, options = {})
-        subscription = billable.subscription
+        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?
+
         response = PaddlePay::Subscription::Charge.create(subscription.processor_id, amount.to_f / 100, options[:charge_name], options)
-        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: processor_subscription(subscription.processor_id).payment_information[:payment_method],
+
+        attributes = {
+          amount: (response[:amount].to_f * 100).to_i,
           paddle_receipt_url: response[:receipt_url],
           created_at: Time.zone.parse(response[:payment_date])
-        )
+        }
+
+        # Lookup subscription payment method details
+        attributes.merge! Pay::Paddle::PaymentMethod.payment_method_details_for(subscription_id: subscription.processor_id)
+
+        charge = pay_customer.charges.find_or_initialize_by(processor_id: response[:invoice_id])
+        charge.update(attributes)
         charge
       rescue ::PaddlePay::PaddlePayError => e
         raise Pay::Paddle::Error, e
@@ -39,8 +45,8 @@ module Pay
         # pass
       end
 
-      def update_card(token)
-        sync_payment_information_from_paddle
+      def add_payment_method(token, default: true)
+        Pay::Paddle::PaymentMethod.sync(self)
       end
 
       def update_email!
@@ -58,42 +64,6 @@ module Pay
       rescue ::PaddlePay::PaddlePayError => e
         raise Pay::Paddle::Error, e
       end
-
-      def invoice!(options = {})
-        # pass
-      end
-
-      def upcoming_invoice
-        # pass
-      end
-
-      def sync_payment_information
-        billable.update!(payment_information(billable.subscription.processor_id))
-      rescue ::PaddlePay::PaddlePayError => e
-        raise Pay::Paddle::Error, e
-      end
-
-      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?
-
-        case payment_information[:payment_method]
-        when "card"
-          {
-            card_type: payment_information[:card_type],
-            card_last4: payment_information[:last_four_digits],
-            card_exp_month: payment_information[:expiry_date].split("/").first,
-            card_exp_year: payment_information[:expiry_date].split("/").last
-          }
-        when "paypal"
-          {
-            card_type: "PayPal"
-          }
-        else
-          {}
-        end
-      end
     end
   end
 end

data/lib/pay/paddle/charge.rb

@@ -3,15 +3,15 @@ module Pay
     class Charge
       attr_reader :pay_charge
 
-      delegate :processor_id, :owner, to: :pay_charge
+      delegate :processor_id, :customer, to: :pay_charge
 
       def initialize(pay_charge)
         @pay_charge = pay_charge
       end
 
       def charge
-        return unless owner.subscription
-        payments = PaddlePay::Subscription::Payment.list({subscription_id: owner.subscription.processor_id})
+        return unless customer.subscription
+        payments = PaddlePay::Subscription::Payment.list({subscription_id: customer.subscription.processor_id})
         charges = payments.select { |p| p[:id].to_s == processor_id }
         charges.try(:first)
       rescue ::PaddlePay::PaddlePayError => e
@@ -19,8 +19,8 @@ module Pay
       end
 
       def refund!(amount_to_refund)
-        return unless owner.subscription
-        payments = PaddlePay::Subscription::Payment.list({subscription_id: owner.subscription.processor_id, is_paid: 1})
+        return unless customer.subscription
+        payments = PaddlePay::Subscription::Payment.list({subscription_id: customer.subscription.processor_id, is_paid: 1})
         if payments.count > 0
           PaddlePay::Subscription::Payment.refund(payments.last[:id], {amount: amount_to_refund})
           pay_charge.update(amount_refunded: amount_to_refund)

data/lib/pay/paddle/payment_method.rb

@@ -0,0 +1,60 @@
+module Pay
+  module Paddle
+    class PaymentMethod
+      attr_reader :pay_payment_method
+
+      delegate :customer, :processor_id, to: :pay_payment_method
+
+      # 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
+
+        payment_method = pay_customer.default_payment_method || pay_customer.build_default_payment_method
+        payment_method.processor_id ||= NanoId.generate
+
+        # Lookup payment method from API unless passed in
+        attributes ||= payment_method_details_for(subscription_id: pay_customer.subscription.processor_id)
+
+        payment_method.update!(attributes)
+        payment_method
+      rescue ::PaddlePay::PaddlePayError => e
+        raise Pay::Paddle::Error, e
+      end
+
+      def self.payment_method_details_for(subscription_id:)
+        subscription_user = PaddlePay::Subscription::User.list({subscription_id: subscription_id}).try(:first)
+        payment_information = subscription_user ? subscription_user[:payment_information] : {}
+
+        case payment_information[:payment_method]
+        when "card"
+          {
+            payment_method_type: :card,
+            brand: payment_information[:card_type],
+            last4: payment_information[:last_four_digits],
+            exp_month: payment_information[:expiry_date].split("/").first,
+            exp_year: payment_information[:expiry_date].split("/").last
+          }
+        when "paypal"
+          {
+            payment_method_type: :paypal,
+            brand: "PayPal"
+          }
+        else
+          {}
+        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
+  end
+end

data/lib/pay/paddle/subscription.rb

@@ -20,6 +20,49 @@ module Pay
         :trial_ends_at,
         to: :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 ||= OpenStruct.new PaddlePay::Subscription::User.list({subscription_id: subscription_id}).try(:first)
+
+        pay_customer = Pay::Customer.find_by(processor: :paddle, processor_id: object.user_id)
+
+        # If passthrough exists (only on webhooks) we can use it to create the Pay::Customer
+        if pay_customer.nil? && object.passthrough
+          owner = Pay::Paddle.owner_from_passthrough(object.passthrough)
+          pay_customer = owner&.set_payment_processor(:paddle, processor_id: object.user_id)
+        end
+
+        return unless pay_customer
+
+        attributes = {
+          paddle_cancel_url: object.cancel_url,
+          paddle_update_url: object.update_url,
+          processor_plan: object.plan_id || object.subscription_plan_id,
+          quantity: object.quantity,
+          status: object.state || object.status
+        }
+
+        # If paused or delete while on trial, set ends_at to match
+        case attributes[:status]
+        when "trialing"
+          attributes[:trial_ends_at] = Time.zone.parse(object.next_bill_date)
+          attributes[:ends_at] = nil
+        when "paused", "deleted"
+          attributes[:trial_ends_at] = nil
+          attributes[:ends_at] = Time.zone.parse(object.next_bill_date)
+        end
+
+        # Update or create the subscription
+        if (pay_subscription = pay_customer.subscriptions.find_by(processor_id: object.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: object.subscription_id))
+        end
+      end
+
       def initialize(pay_subscription)
         @pay_subscription = pay_subscription
       end
@@ -32,26 +75,22 @@ module Pay
       end
 
       def cancel
-        subscription = processor_subscription
+        ends_at = on_trial? ? trial_ends_at : processor_subscription.next_payment[:date]
         PaddlePay::Subscription::User.cancel(processor_id)
-        if on_trial?
-          pay_subscription.update(status: :canceled, ends_at: trial_ends_at)
-        else
-          pay_subscription.update(status: :canceled, ends_at: Time.zone.parse(subscription.next_payment[:date]))
-        end
+        pay_subscription.update(status: :canceled, ends_at: ends_at)
       rescue ::PaddlePay::PaddlePayError => e
         raise Pay::Paddle::Error, e
       end
 
       def cancel_now!
         PaddlePay::Subscription::User.cancel(processor_id)
-        pay_subscription.update(status: :canceled, ends_at: Time.zone.now)
+        pay_subscription.update(status: :canceled, ends_at: Time.current)
       rescue ::PaddlePay::PaddlePayError => e
         raise Pay::Paddle::Error, e
       end
 
       def on_grace_period?
-        canceled? && Time.zone.now < ends_at || paused? && Time.zone.now < paddle_paused_from
+        canceled? && Time.current < ends_at || paused? && Time.current < paddle_paused_from
       end
 
       def paused?
@@ -79,6 +118,8 @@ module Pay
       end
 
       def swap(plan)
+        raise ArgumentError, "plan must be a string" unless plan.is_a?(String)
+
         attributes = {plan_id: plan, prorate: prorate}
         attributes[:quantity] = quantity if quantity?
         PaddlePay::Subscription::User.update(processor_id, attributes)

data/lib/pay/paddle/webhooks/subscription_cancelled.rb

@@ -3,14 +3,17 @@ module Pay
     module Webhooks
       class SubscriptionCancelled
         def call(event)
-          subscription = Pay.subscription_model.find_by(processor: :paddle, processor_id: event["subscription_id"])
+          pay_subscription = Pay::Subscription.find_by_processor_and_id(:paddle, event.subscription_id)
 
           # We couldn't find the subscription for some reason, maybe it's from another service
-          return if subscription.nil?
+          return if pay_subscription.nil?
 
           # User canceled subscriptions have an ends_at
           # Automatically canceled subscriptions need this value set
-          subscription.update!(ends_at: Time.zone.parse(event["cancellation_effective_date"])) if subscription.ends_at.blank? && event["cancellation_effective_date"].present?
+          pay_subscription.update!(ends_at: Time.zone.parse(event.cancellation_effective_date)) if pay_subscription.ends_at.blank? && event.cancellation_effective_date.present?
+
+          # Paddle doesn't allow reusing customers, so we should remove their payment methods
+          pay_subscription.customer.payment_methods.destroy_all
         end
       end
     end

data/lib/pay/paddle/webhooks/subscription_created.rb

@@ -3,46 +3,7 @@ module Pay
     module Webhooks
       class SubscriptionCreated
         def call(event)
-          # We may already have the subscription in the database, so we can update that record
-          subscription = Pay.subscription_model.find_by(processor: :paddle, processor_id: event["subscription_id"])
-
-          # Create the subscription in the database if we don't have it already
-          if subscription.nil?
-
-            # The customer could already be in the database
-            owner = Pay.find_billable(processor: :paddle, processor_id: event["user_id"])
-
-            if owner.nil?
-              owner = Pay::Paddle.owner_from_passthrough(event["passthrough"])
-              owner&.update!(processor: "paddle", processor_id: event["user_id"])
-            end
-
-            if owner.nil?
-              Rails.logger.error("[Pay] Unable to find Pay::Billable with owner: '#{event["passthrough"]}'. Searched these models: #{Pay.billable_models.join(", ")}")
-              return
-            end
-
-            subscription = Pay.subscription_model.new(owner: owner, name: Pay.default_product_name, processor: "paddle", processor_id: event["subscription_id"], status: :active)
-          end
-
-          subscription.quantity = event["quantity"]
-          subscription.processor_plan = event["subscription_plan_id"]
-          subscription.paddle_update_url = event["update_url"]
-          subscription.paddle_cancel_url = event["cancel_url"]
-          subscription.trial_ends_at = Time.zone.parse(event["next_bill_date"]) if event["status"] == "trialing"
-
-          # If user was on trial, their subscription ends at the end of the trial
-          subscription.ends_at = if ["paused", "deleted"].include?(event["status"]) && subscription.on_trial?
-            subscription.trial_ends_at
-
-          # User wasn't on trial, so subscription ends at period end
-          elsif ["paused", "deleted"].include?(event["status"])
-            Time.zone.parse(event["next_bill_date"])
-
-            # Subscription isn't marked to cancel at period end
-          end
-
-          subscription.save!
+          Pay::Paddle::Subscription.sync(event.subscription_id, object: event)
         end
       end
     end

data/lib/pay/paddle/webhooks/subscription_payment_refunded.rb

@@ -3,11 +3,11 @@ module Pay
     module Webhooks
       class SubscriptionPaymentRefunded
         def call(event)
-          charge = Pay.charge_model.find_by(processor: :paddle, processor_id: event["subscription_payment_id"])
+          charge = Pay::Charge.find_by_processor_and_id(:paddle, event.subscription_payment_id)
           return unless charge.present?
 
-          charge.update(amount_refunded: Integer(event["gross_refund"].to_f * 100))
-          notify_user(charge.owner, charge)
+          charge.update(amount_refunded: (event.gross_refund.to_f * 100).to_i)
+          notify_user(charge.customer.owner, charge)
         end
 
         def notify_user(billable, charge)

data/lib/pay/paddle/webhooks/subscription_payment_succeeded.rb

@@ -3,43 +3,41 @@ module Pay
     module Webhooks
       class SubscriptionPaymentSucceeded
         def call(event)
-          billable = Pay.find_billable(processor: :paddle, processor_id: event["user_id"])
+          pay_customer = Pay::Customer.find_by(processor: :paddle, processor_id: event.user_id)
 
-          if billable.nil?
-            billable = Pay::Paddle.owner_from_passthrough(event["passthrough"])
-            billable&.update!(processor: "paddle", processor_id: event["user_id"])
+          if pay_customer.nil?
+            owner = Pay::Paddle.owner_from_passthrough(event.passthrough)
+            pay_customer = owner&.set_payment_processor :paddle, processor_id: event.user_id
           end
 
-          if billable.nil?
-            Rails.logger.error("[Pay] Unable to find Pay::Billable with owner: '#{event["passthrough"]}'. Searched these models: #{Pay.billable_models.join(", ")}")
+          if pay_customer.nil?
+            Rails.logger.error("[Pay] Unable to find Pay::Customer with: '#{event.passthrough}'")
             return
           end
 
-          return if billable.charges.where(processor_id: event["subscription_payment_id"]).any?
+          return if pay_customer.charges.where(processor_id: event.subscription_payment_id).any?
 
-          charge = create_charge(billable, event)
-          notify_user(billable, charge)
+          charge = create_charge(pay_customer, event)
+          notify_user(pay_customer.owner, charge)
         end
 
-        def create_charge(user, event)
-          charge = user.charges.find_or_initialize_by(
-            processor: :paddle,
-            processor_id: event["subscription_payment_id"]
-          )
-
-          params = {
-            amount: Integer(event["sale_gross"].to_f * 100),
-            card_type: event["payment_method"],
-            created_at: Time.zone.parse(event["event_time"]),
-            currency: event["currency"],
-            paddle_receipt_url: event["receipt_url"],
-            subscription: Pay::Subscription.find_by(processor: :paddle, processor_id: event["subscription_id"])
-          }
-
-          payment_information = Pay::Paddle::Billable.new(user).payment_information(event["subscription_id"])
-
-          charge.update(params.merge(payment_information))
-          user.update(payment_information)
+        def create_charge(pay_customer, event)
+          payment_method_details = Pay::Paddle::PaymentMethod.payment_method_details_for(subscription_id: event.subscription_id)
+
+          attributes = {
+            amount: (event.sale_gross.to_f * 100).to_i,
+            created_at: Time.zone.parse(event.event_time),
+            currency: event.currency,
+            paddle_receipt_url: event.receipt_url,
+            subscription: pay_customer.subscriptions.find_by(processor_id: event.subscription_id),
+            metadata: Pay::Paddle.parse_passthrough(event.passthrough).except("owner_sgid")
+          }.merge(payment_method_details)
+
+          charge = pay_customer.charges.find_or_initialize_by(processor_id: event.subscription_payment_id)
+          charge.update!(attributes)
+
+          # Update customer's payment method
+          Pay::Paddle::PaymentMethod.sync(pay_customer: pay_customer, attributes: payment_method_details)
 
           charge
         end

data/lib/pay/paddle/webhooks/subscription_updated.rb

@@ -3,14 +3,14 @@ module Pay
     module Webhooks
       class SubscriptionUpdated
         def call(event)
-          subscription = Pay.subscription_model.find_by(processor: :paddle, processor_id: event["subscription_id"])
+          subscription = Pay::Subscription.find_by_processor_and_id(:paddle, event["subscription_id"])
 
           return if subscription.nil?
 
           case event["status"]
           when "deleted"
             subscription.status = "canceled"
-            subscription.ends_at = Time.zone.parse(event["next_bill_date"]) || Time.zone.now if subscription.ends_at.blank?
+            subscription.ends_at = Time.zone.parse(event["next_bill_date"]) || Time.current if subscription.ends_at.blank?
           when "trialing"
             subscription.status = "trialing"
             subscription.trial_ends_at = Time.zone.parse(event["next_bill_date"])