pay 2.4.0 → 2.6.0

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

@@ -2,15 +2,15 @@ module Pay
   module Paddle
     module Webhooks
       class SubscriptionCancelled
-        def initialize(data)
-          subscription = Pay.subscription_model.find_by(processor: :paddle, processor_id: data["subscription_id"])
+        def call(event)
+          subscription = Pay.subscription_model.find_by(processor: :paddle, processor_id: event["subscription_id"])
 
           # We couldn't find the subscription for some reason, maybe it's from another service
           return if subscription.nil?
 
           # User canceled subscriptions have an ends_at
           # Automatically canceled subscriptions need this value set
-          subscription.update!(ends_at: Time.zone.parse(data["cancellation_effective_date"])) if subscription.ends_at.blank? && data["cancellation_effective_date"].present?
+          subscription.update!(ends_at: Time.zone.parse(event["cancellation_effective_date"])) if subscription.ends_at.blank? && event["cancellation_effective_date"].present?
         end
       end
     end

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

@@ -2,42 +2,42 @@ module Pay
   module Paddle
     module Webhooks
       class SubscriptionCreated
-        def initialize(data)
+        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: data["subscription_id"])
+          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: data["user_id"])
+            owner = Pay.find_billable(processor: :paddle, processor_id: event["user_id"])
 
             if owner.nil?
-              owner = owner_by_passtrough(data["passthrough"], data["subscription_plan_id"])
-              owner&.update!(processor: "paddle", processor_id: data["user_id"])
+              owner = owner_by_passtrough(event["passthrough"], event["subscription_plan_id"])
+              owner&.update!(processor: "paddle", processor_id: event["user_id"])
             end
 
             if owner.nil?
-              Rails.logger.error("[Pay] Unable to find Pay::Billable with owner: '#{data["passthrough"]}'. Searched these models: #{Pay.billable_models.join(", ")}")
+              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: data["subscription_id"], status: :active)
+            subscription = Pay.subscription_model.new(owner: owner, name: Pay.default_product_name, processor: "paddle", processor_id: event["subscription_id"], status: :active)
           end
 
-          subscription.quantity = data["quantity"]
-          subscription.processor_plan = data["subscription_plan_id"]
-          subscription.paddle_update_url = data["update_url"]
-          subscription.paddle_cancel_url = data["cancel_url"]
-          subscription.trial_ends_at = Time.zone.parse(data["next_bill_date"]) if data["status"] == "trialing"
+          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?(data["status"]) && subscription.on_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?(data["status"])
-            Time.zone.parse(data["next_bill_date"])
+          elsif ["paused", "deleted"].include?(event["status"])
+            Time.zone.parse(event["next_bill_date"])
 
             # Subscription isn't marked to cancel at period end
           end

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

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

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

@@ -2,29 +2,29 @@ module Pay
   module Paddle
     module Webhooks
       class SubscriptionPaymentSucceeded
-        def initialize(data)
-          billable = Pay.find_billable(processor: :paddle, processor_id: data["user_id"])
+        def call(event)
+          billable = Pay.find_billable(processor: :paddle, processor_id: event["user_id"])
           return unless billable.present?
-          return if billable.charges.where(processor_id: data["subscription_payment_id"]).any?
+          return if billable.charges.where(processor_id: event["subscription_payment_id"]).any?
 
-          charge = create_charge(billable, data)
+          charge = create_charge(billable, event)
           notify_user(billable, charge)
         end
 
-        def create_charge(user, data)
+        def create_charge(user, event)
           charge = user.charges.find_or_initialize_by(
             processor: :paddle,
-            processor_id: data["subscription_payment_id"]
+            processor_id: event["subscription_payment_id"]
           )
 
           params = {
-            amount: Integer(data["sale_gross"].to_f * 100),
-            card_type: data["payment_method"],
-            paddle_receipt_url: data["receipt_url"],
-            created_at: Time.zone.parse(data["event_time"])
+            amount: Integer(event["sale_gross"].to_f * 100),
+            card_type: event["payment_method"],
+            paddle_receipt_url: event["receipt_url"],
+            created_at: Time.zone.parse(event["event_time"])
           }
 
-          payment_information = user.paddle_payment_information(data["subscription_id"])
+          payment_information = Pay::Paddle::Billable.new(user).payment_information(event["subscription_id"])
 
           charge.update(params.merge(payment_information))
           user.update(payment_information)

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

@@ -2,29 +2,29 @@ module Pay
   module Paddle
     module Webhooks
       class SubscriptionUpdated
-        def initialize(data)
-          subscription = Pay.subscription_model.find_by(processor: :paddle, processor_id: data["subscription_id"])
+        def call(event)
+          subscription = Pay.subscription_model.find_by(processor: :paddle, processor_id: event["subscription_id"])
 
           return if subscription.nil?
 
-          case data["status"]
+          case event["status"]
           when "deleted"
             subscription.status = "canceled"
-            subscription.ends_at = Time.zone.parse(data["next_bill_date"]) || Time.zone.now if subscription.ends_at.blank?
+            subscription.ends_at = Time.zone.parse(event["next_bill_date"]) || Time.zone.now if subscription.ends_at.blank?
           when "trialing"
             subscription.status = "trialing"
-            subscription.trial_ends_at = Time.zone.parse(data["next_bill_date"])
+            subscription.trial_ends_at = Time.zone.parse(event["next_bill_date"])
           when "active"
             subscription.status = "active"
-            subscription.paddle_paused_from = Time.zone.parse(data["paused_from"]) if data["paused_from"].present?
+            subscription.paddle_paused_from = Time.zone.parse(event["paused_from"]) if event["paused_from"].present?
           else
-            subscription.status = data["status"]
+            subscription.status = event["status"]
           end
 
-          subscription.quantity = data["new_quantity"]
-          subscription.processor_plan = data["subscription_plan_id"]
-          subscription.paddle_update_url = data["update_url"]
-          subscription.paddle_cancel_url = data["cancel_url"]
+          subscription.quantity = event["new_quantity"]
+          subscription.processor_plan = event["subscription_plan_id"]
+          subscription.paddle_update_url = event["update_url"]
+          subscription.paddle_cancel_url = event["cancel_url"]
 
           # If user was on trial, their subscription ends at the end of the trial
           subscription.ends_at = subscription.trial_ends_at if subscription.on_trial?

data/lib/pay/stripe.rb

@@ -1,34 +1,84 @@
-require "pay/env"
-require "pay/stripe/billable"
-require "pay/stripe/charge"
-require "pay/stripe/subscription"
-require "pay/stripe/webhooks"
-
 module Pay
   module Stripe
-    include Env
+    autoload :Billable, "pay/stripe/billable"
+    autoload :Charge, "pay/stripe/charge"
+    autoload :Subscription, "pay/stripe/subscription"
+    autoload :Error, "pay/stripe/error"
+
+    module Webhooks
+      autoload :ChargeRefunded, "pay/stripe/webhooks/charge_refunded"
+      autoload :ChargeSucceeded, "pay/stripe/webhooks/charge_succeeded"
+      autoload :CustomerDeleted, "pay/stripe/webhooks/customer_deleted"
+      autoload :CustomerUpdated, "pay/stripe/webhooks/customer_updated"
+      autoload :PaymentActionRequired, "pay/stripe/webhooks/payment_action_required"
+      autoload :PaymentMethodUpdated, "pay/stripe/webhooks/payment_method_updated"
+      autoload :SubscriptionCreated, "pay/stripe/webhooks/subscription_created"
+      autoload :SubscriptionDeleted, "pay/stripe/webhooks/subscription_deleted"
+      autoload :SubscriptionRenewing, "pay/stripe/webhooks/subscription_renewing"
+      autoload :SubscriptionUpdated, "pay/stripe/webhooks/subscription_updated"
+    end
 
-    extend self
+    extend Env
 
-    def setup
+    def self.setup
       ::Stripe.api_key = private_key
       ::Stripe.api_version = "2020-08-27"
-      ::StripeEvent.signing_secret = signing_secret
 
-      Pay.charge_model.include Pay::Stripe::Charge
-      Pay.subscription_model.include Pay::Stripe::Subscription
+      # Used by Stripe to identify Pay for support
+      ::Stripe.set_app_info("PayRails", partner_id: "pp_partner_IqhY0UExnJYLxg", version: Pay::VERSION, url: "https://github.com/pay-rails/pay")
+
+      configure_webhooks
     end
 
-    def public_key
+    def self.public_key
       find_value_by_name(:stripe, :public_key)
     end
 
-    def private_key
+    def self.private_key
       find_value_by_name(:stripe, :private_key)
     end
 
-    def signing_secret
+    def self.signing_secret
       find_value_by_name(:stripe, :signing_secret)
     end
+
+    def self.configure_webhooks
+      Pay::Webhooks.configure do |events|
+        # Listen to the charge event to make sure we get non-subscription
+        # purchases as well. Invoice is only for subscriptions and manual creation
+        # so it does not include individual charges.
+        events.subscribe "stripe.charge.succeeded", Pay::Stripe::Webhooks::ChargeSucceeded.new
+        events.subscribe "stripe.charge.refunded", Pay::Stripe::Webhooks::ChargeRefunded.new
+
+        # Warn user of upcoming charges for their subscription. This is handy for
+        # notifying annual users their subscription will renew shortly.
+        # This probably should be ignored for monthly subscriptions.
+        events.subscribe "stripe.invoice.upcoming", Pay::Stripe::Webhooks::SubscriptionRenewing.new
+
+        # Payment action is required to process an invoice
+        events.subscribe "stripe.invoice.payment_action_required", Pay::Stripe::Webhooks::PaymentActionRequired.new
+
+        # If a subscription is manually created on Stripe, we want to sync
+        events.subscribe "stripe.customer.subscription.created", Pay::Stripe::Webhooks::SubscriptionCreated.new
+
+        # If the plan, quantity, or trial ending date is updated on Stripe, we want to sync
+        events.subscribe "stripe.customer.subscription.updated", Pay::Stripe::Webhooks::SubscriptionUpdated.new
+
+        # When a customers subscription is canceled, we want to update our records
+        events.subscribe "stripe.customer.subscription.deleted", Pay::Stripe::Webhooks::SubscriptionDeleted.new
+
+        # Monitor changes for customer's default card changing
+        events.subscribe "stripe.customer.updated", Pay::Stripe::Webhooks::CustomerUpdated.new
+
+        # If a customer was deleted in Stripe, their subscriptions should be cancelled
+        events.subscribe "stripe.customer.deleted", Pay::Stripe::Webhooks::CustomerDeleted.new
+
+        # If a customer's payment source was deleted in Stripe, we should update as well
+        events.subscribe "stripe.payment_method.attached", Pay::Stripe::Webhooks::PaymentMethodUpdated.new
+        events.subscribe "stripe.payment_method.updated", Pay::Stripe::Webhooks::PaymentMethodUpdated.new
+        events.subscribe "stripe.payment_method.card_automatically_updated", Pay::Stripe::Webhooks::PaymentMethodUpdated.new
+        events.subscribe "stripe.payment_method.detached", Pay::Stripe::Webhooks::PaymentMethodUpdated.new
+      end
+    end
   end
 end

data/lib/pay/stripe/billable.rb

@@ -1,51 +1,71 @@
 module Pay
   module Stripe
-    module Billable
-      extend ActiveSupport::Concern
+    class Billable
+      include Rails.application.routes.url_helpers
 
-      included do
-        scope :stripe, -> { where(processor: :stripe) }
+      attr_reader :billable
+
+      delegate :processor_id,
+        :processor_id?,
+        :email,
+        :customer_name,
+        :card_token,
+        to: :billable
+
+      class << self
+        def default_url_options
+          Rails.application.config.action_mailer.default_url_options
+        end
+      end
+
+      def initialize(billable)
+        @billable = billable
       end
 
       # Handles Billable#customer
       #
       # Returns Stripe::Customer
-      def stripe_customer
+      def customer
         if processor_id?
           ::Stripe::Customer.retrieve(processor_id)
         else
-          create_stripe_customer
+          stripe_customer = ::Stripe::Customer.create(email: email, name: customer_name)
+          billable.update(processor: :stripe, processor_id: stripe_customer.id)
+
+          # Update the user's card on file if a token was passed in
+          if card_token.present?
+            payment_method = ::Stripe::PaymentMethod.attach(card_token, {customer: stripe_customer.id})
+            stripe_customer.invoice_settings.default_payment_method = payment_method.id
+            stripe_customer.save
+
+            update_card_on_file ::Stripe::PaymentMethod.retrieve(card_token).card
+          end
+
+          stripe_customer
         end
       rescue ::Stripe::StripeError => e
         raise Pay::Stripe::Error, e
       end
 
-      def create_setup_intent
-        ::Stripe::SetupIntent.create(
-          customer: processor_id,
-          usage: :off_session
-        )
-      end
-
       # Handles Billable#charge
       #
       # Returns Pay::Charge
-      def create_stripe_charge(amount, options = {})
-        customer = stripe_customer
+      def charge(amount, options = {})
+        stripe_customer = customer
         args = {
           amount: amount,
           confirm: true,
           confirmation_method: :automatic,
           currency: "usd",
-          customer: customer.id,
-          payment_method: customer.invoice_settings.default_payment_method
+          customer: stripe_customer.id,
+          payment_method: stripe_customer.invoice_settings.default_payment_method
         }.merge(options)
 
         payment_intent = ::Stripe::PaymentIntent.create(args)
         Pay::Payment.new(payment_intent).validate
 
         # Create a new charge object
-        Stripe::Webhooks::ChargeSucceeded.new.create_charge(self, payment_intent.charges.first)
+        save_pay_charge(payment_intent.charges.first)
       rescue ::Stripe::StripeError => e
         raise Pay::Stripe::Error, e
       end
@@ -53,7 +73,7 @@ module Pay
       # Handles Billable#subscribe
       #
       # Returns Pay::Subscription
-      def create_stripe_subscription(name, plan, options = {})
+      def subscribe(name: Pay.default_product_name, plan: Pay.default_plan_name, **options)
         quantity = options.delete(:quantity) || 1
         opts = {
           expand: ["pending_setup_intent", "latest_invoice.payment_intent"],
@@ -64,10 +84,10 @@ module Pay
         # Inherit trial from plan unless trial override was specified
         opts[:trial_from_plan] = true unless opts[:trial_period_days]
 
-        opts[:customer] = stripe_customer.id
+        opts[:customer] = customer.id
 
         stripe_sub = ::Stripe::Subscription.create(opts)
-        subscription = create_subscription(stripe_sub, "stripe", name, plan, status: stripe_sub.status, quantity: quantity)
+        subscription = billable.create_pay_subscription(stripe_sub, "stripe", name, plan, status: stripe_sub.status, quantity: quantity)
 
         # No trial, card requires SCA
         if subscription.incomplete?
@@ -86,93 +106,131 @@ module Pay
       # Handles Billable#update_card
       #
       # Returns true if successful
-      def update_stripe_card(payment_method_id)
-        customer = stripe_customer
+      def update_card(payment_method_id)
+        stripe_customer = customer
 
-        return true if payment_method_id == customer.invoice_settings.default_payment_method
+        return true if payment_method_id == stripe_customer.invoice_settings.default_payment_method
 
-        payment_method = ::Stripe::PaymentMethod.attach(payment_method_id, customer: customer.id)
-        ::Stripe::Customer.update(customer.id, invoice_settings: {default_payment_method: payment_method.id})
+        payment_method = ::Stripe::PaymentMethod.attach(payment_method_id, customer: stripe_customer.id)
+        ::Stripe::Customer.update(stripe_customer.id, invoice_settings: {default_payment_method: payment_method.id})
 
-        update_stripe_card_on_file(payment_method.card)
+        update_card_on_file(payment_method.card)
         true
       rescue ::Stripe::StripeError => e
         raise Pay::Stripe::Error, e
       end
 
-      def update_stripe_email!
-        customer = stripe_customer
-        customer.email = email
-        customer.name = customer_name
-        customer.save
+      def update_email!
+        ::Stripe::Customer.update(processor_id, {email: email, name: customer_name})
       end
 
-      def stripe_subscription(subscription_id, options = {})
+      def processor_subscription(subscription_id, options = {})
         ::Stripe::Subscription.retrieve(options.merge(id: subscription_id))
       end
 
-      def stripe_invoice!(options = {})
+      def invoice!(options = {})
         return unless processor_id?
         ::Stripe::Invoice.create(options.merge(customer: processor_id)).pay
       end
 
-      def stripe_upcoming_invoice
+      def upcoming_invoice
         ::Stripe::Invoice.upcoming(customer: processor_id)
       end
 
       # Used by webhooks when the customer or source changes
       def sync_card_from_stripe
-        stripe_cust = stripe_customer
-        default_payment_method_id = stripe_cust.invoice_settings.default_payment_method
-
-        if default_payment_method_id.present?
-          payment_method = ::Stripe::PaymentMethod.retrieve(default_payment_method_id)
-          update(
-            card_type: payment_method.card.brand,
-            card_last4: payment_method.card.last4,
-            card_exp_month: payment_method.card.exp_month,
-            card_exp_year: payment_method.card.exp_year
-          )
-
-        # Customer has no default payment method
+        if (payment_method_id = customer.invoice_settings.default_payment_method)
+          update_card_on_file ::Stripe::PaymentMethod.retrieve(payment_method_id).card
         else
-          update(card_type: nil, card_last4: nil)
+          billable.update(card_type: nil, card_last4: nil)
         end
       end
 
-      private
-
-      def create_stripe_customer
-        customer = ::Stripe::Customer.create(email: email, name: customer_name)
-        update(processor: "stripe", processor_id: customer.id)
-
-        # Update the user's card on file if a token was passed in
-        if card_token.present?
-          payment_method = ::Stripe::PaymentMethod.attach(card_token, {customer: customer.id})
-          customer.invoice_settings.default_payment_method = payment_method.id
-          customer.save
-
-          update_stripe_card_on_file ::Stripe::PaymentMethod.retrieve(card_token).card
-        end
-
-        customer
+      def create_setup_intent
+        ::Stripe::SetupIntent.create(customer: processor_id, usage: :off_session)
       end
 
-      def stripe_trial_end_date(stripe_sub)
+      def trial_end_date(stripe_sub)
         # Times in Stripe are returned in UTC
         stripe_sub.trial_end.present? ? Time.at(stripe_sub.trial_end) : nil
       end
 
       # Save the card to the database as the user's current card
-      def update_stripe_card_on_file(card)
-        update!(
+      def update_card_on_file(card)
+        billable.update!(
           card_type: card.brand.capitalize,
           card_last4: card.last4,
           card_exp_month: card.exp_month,
           card_exp_year: card.exp_year
         )
 
-        self.card_token = nil
+        billable.card_token = nil
+      end
+
+      def save_pay_charge(object)
+        charge = billable.charges.find_or_initialize_by(processor: :stripe, processor_id: object.id)
+
+        charge.update(
+          amount: object.amount,
+          card_last4: object.payment_method_details.card.last4,
+          card_type: object.payment_method_details.card.brand,
+          card_exp_month: object.payment_method_details.card.exp_month,
+          card_exp_year: object.payment_method_details.card.exp_year,
+          created_at: Time.zone.at(object.created)
+        )
+
+        charge
+      end
+
+      # https://stripe.com/docs/api/checkout/sessions/create
+      #
+      # checkout(mode: "payment")
+      # checkout(mode: "setup")
+      # checkout(mode: "subscription")
+      #
+      # checkout(line_items: "price_12345", quantity: 2)
+      # checkout(line_items [{ price: "price_123" }, { price: "price_456" }])
+      # checkout(line_items, "price_12345", allow_promotion_codes: true)
+      #
+      def checkout(**options)
+        args = {
+          payment_method_types: ["card"],
+          mode: "payment",
+          # These placeholder URLs will be replaced in a following step.
+          success_url: root_url,
+          cancel_url: root_url
+        }
+
+        # Line items are optional
+        if (line_items = options.delete(:line_items))
+          args[:line_items] = Array.wrap(line_items).map { |item|
+            if item.is_a? Hash
+              item
+            else
+              {price: item, quantity: options.fetch(:quantity, 1)}
+            end
+          }
+        end
+
+        ::Stripe::Checkout::Session.create(args.merge(options))
+      end
+
+      # https://stripe.com/docs/api/checkout/sessions/create
+      #
+      # checkout_charge(amount: 15_00, name: "T-shirt", quantity: 2)
+      #
+      def checkout_charge(amount:, name:, quantity: 1, **options)
+        checkout(
+          line_items: {
+            price_data: {
+              currency: options[:currency] || "usd",
+              product_data: {name: name},
+              unit_amount: amount
+            },
+            quantity: quantity
+          },
+          **options
+        )
       end
     end
   end