pay 2.5.0 → 2.6.4

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

@@ -24,7 +24,7 @@ module Pay
             created_at: Time.zone.parse(event["event_time"])
           }
 
-          payment_information = user.paddle_payment_information(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)

data/lib/pay/stripe.rb

@@ -1,36 +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"
 
       # 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")
 
-      Pay.charge_model.include Pay::Stripe::Charge
-      Pay.subscription_model.include Pay::Stripe::Subscription
+      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,140 @@ 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 = {
+          customer: processor_id,
+          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
+
+      def billing_portal(**options)
+        args = {
+          customer: processor_id,
+          return_url: options[:return_url] || root_url
+        }
+        ::Stripe::BillingPortal::Session.create(args.merge(options))
       end
     end
   end

data/lib/pay/stripe/charge.rb

@@ -1,29 +1,23 @@
 module Pay
   module Stripe
-    module Charge
-      extend ActiveSupport::Concern
+    class Charge
+      attr_reader :pay_charge
 
-      included do
-        scope :stripe, -> { where(processor: :stripe) }
-      end
+      delegate :processor_id, :owner, to: :pay_charge
 
-      def stripe?
-        processor == "stripe"
+      def initialize(pay_charge)
+        @pay_charge = pay_charge
       end
 
-      def stripe_charge
+      def charge
         ::Stripe::Charge.retrieve(processor_id)
       rescue ::Stripe::StripeError => e
         raise Pay::Stripe::Error, e
       end
 
-      def stripe_refund!(amount_to_refund)
-        ::Stripe::Refund.create(
-          charge: processor_id,
-          amount: amount_to_refund
-        )
-
-        update(amount_refunded: amount_to_refund)
+      def refund!(amount_to_refund)
+        ::Stripe::Refund.create(charge: processor_id, amount: amount_to_refund)
+        pay_charge.update(amount_refunded: amount_to_refund)
       rescue ::Stripe::StripeError => e
         raise Pay::Stripe::Error, e
       end

data/lib/pay/stripe/error.rb

@@ -0,0 +1,9 @@
+module Pay
+  module Stripe
+    class Error < Pay::Error
+      def message
+        I18n.t("errors.stripe.#{result.code}", default: result.message)
+      end
+    end
+  end
+end