pay 2.6.2 → 2.6.7

data/lib/pay/fake_processor/billable.rb

@@ -0,0 +1,60 @@
+module Pay
+  module FakeProcessor
+    class Billable
+      attr_reader :billable
+
+      delegate :processor_id,
+        :processor_id?,
+        :email,
+        :customer_name,
+        :card_token,
+        to: :billable
+
+      def initialize(billable)
+        @billable = billable
+      end
+
+      def customer
+        billable
+      end
+
+      def charge(amount, options = {})
+        billable.charges.create(
+          processor: :fake_processor,
+          processor_id: rand(100_000_000),
+          amount: amount,
+          card_type: :fake,
+          card_last4: 1234,
+          card_exp_month: Date.today.month,
+          card_exp_year: Date.today.year
+        )
+      end
+
+      def subscribe(name: Pay.default_product_name, plan: Pay.default_plan_name, **options)
+        subscription = OpenStruct.new id: rand(1_000_000)
+        billable.create_pay_subscription(subscription, :fake_processor, name, plan, status: :active, quantity: options.fetch(:quantity, 1))
+      end
+
+      def update_card(payment_method_id)
+        billable.update(
+          card_type: :fake,
+          card_last4: 1234,
+          card_exp_month: Date.today.month,
+          card_exp_year: Date.today.year
+        )
+      end
+
+      def update_email!
+        # pass
+      end
+
+      def processor_subscription(subscription_id, options = {})
+        billable.subscriptions.find_by(processor: :fake_processor, processor_id: subscription_id)
+      end
+
+      def trial_end_date(subscription)
+        Date.today
+      end
+    end
+  end
+end

data/lib/pay/fake_processor/charge.rb

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

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

data/lib/pay/fake_processor/subscription.rb

@@ -0,0 +1,55 @@
+module Pay
+  module FakeProcessor
+    class Subscription
+      attr_reader :pay_subscription
+
+      delegate :canceled?,
+        :ends_at,
+        :on_trial?,
+        :owner,
+        :processor_subscription,
+        :processor_id,
+        :prorate,
+        :processor_plan,
+        :quantity?,
+        :quantity,
+        to: :pay_subscription
+
+      def initialize(pay_subscription)
+        @pay_subscription = pay_subscription
+      end
+
+      def cancel
+        pay_subscription.update(ends_at: Time.current.end_of_month)
+      end
+
+      def cancel_now!
+        pay_subscription.update(ends_at: Time.current, status: :canceled)
+      end
+
+      def on_grace_period?
+        canceled? && Time.zone.now < ends_at
+      end
+
+      def paused?
+        false
+      end
+
+      def pause
+        raise NotImplementedError, "FakeProcessor does not support pausing subscriptions"
+      end
+
+      def resume
+        unless on_grace_period?
+          raise StandardError, "You can only resume subscriptions within their grace period."
+        end
+
+        pay_subscription.update(ends_at: nil, status: :active)
+      end
+
+      def swap(plan)
+        pay_subscription.update(processor_plan: plan)
+      end
+    end
+  end
+end

data/lib/pay/paddle.rb

@@ -19,6 +19,7 @@ module Pay
     def self.setup
       ::PaddlePay.config.vendor_id = vendor_id
       ::PaddlePay.config.vendor_auth_code = vendor_auth_code
+      ::PaddlePay.config.environment = environment
 
       configure_webhooks
     end
@@ -31,6 +32,10 @@ module Pay
       find_value_by_name(:paddle, :vendor_auth_code)
     end
 
+    def self.environment
+      find_value_by_name(:paddle, :environment) || "production"
+    end
+
     def self.public_key_base64
       find_value_by_name(:paddle, :public_key_base64)
     end

data/lib/pay/paddle/error.rb

@@ -1,9 +1,7 @@
 module Pay
   module Paddle
     class Error < Pay::Error
-      def message
-        I18n.t("errors.paddle.#{result.code}", default: result.message)
-      end
+      delegate :message, to: :cause
     end
   end
 end

data/lib/pay/paddle/subscription.rb

@@ -3,8 +3,10 @@ module Pay
     class Subscription
       attr_reader :pay_subscription
 
-      delegate :canceled?,
+      delegate :active?,
+        :canceled?,
         :ends_at,
+        :name,
         :on_trial?,
         :owner,
         :paddle_paused_from,
@@ -12,8 +14,10 @@ module Pay
         :processor_plan,
         :processor_subscription,
         :prorate,
+        :prorate?,
         :quantity,
         :quantity?,
+        :trial_ends_at,
         to: :pay_subscription
 
       def initialize(pay_subscription)

data/lib/pay/stripe.rb

@@ -11,6 +11,7 @@ module Pay
       autoload :CustomerDeleted, "pay/stripe/webhooks/customer_deleted"
       autoload :CustomerUpdated, "pay/stripe/webhooks/customer_updated"
       autoload :PaymentActionRequired, "pay/stripe/webhooks/payment_action_required"
+      autoload :PaymentIntentSucceeded, "pay/stripe/webhooks/payment_intent_succeeded"
       autoload :PaymentMethodUpdated, "pay/stripe/webhooks/payment_method_updated"
       autoload :SubscriptionCreated, "pay/stripe/webhooks/subscription_created"
       autoload :SubscriptionDeleted, "pay/stripe/webhooks/subscription_deleted"
@@ -50,6 +51,8 @@ module Pay
         events.subscribe "stripe.charge.succeeded", Pay::Stripe::Webhooks::ChargeSucceeded.new
         events.subscribe "stripe.charge.refunded", Pay::Stripe::Webhooks::ChargeRefunded.new
 
+        events.subscribe "stripe.payment_intent.succeeded", Pay::Stripe::Webhooks::PaymentIntentSucceeded.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.

data/lib/pay/stripe/billable.rb

@@ -14,7 +14,7 @@ module Pay
 
       class << self
         def default_url_options
-          Rails.application.config.action_mailer.default_url_options
+          Rails.application.config.action_mailer.default_url_options || {}
         end
       end
 

data/lib/pay/stripe/error.rb

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

data/lib/pay/stripe/subscription.rb

@@ -3,16 +3,20 @@ module Pay
     class Subscription
       attr_reader :pay_subscription
 
-      delegate :canceled?,
+      delegate :active?,
+        :canceled?,
         :ends_at,
+        :name,
         :on_trial?,
         :owner,
-        :processor_subscription,
         :processor_id,
-        :prorate,
         :processor_plan,
-        :quantity?,
+        :processor_subscription,
+        :prorate,
+        :prorate?,
         :quantity,
+        :quantity?,
+        :trial_ends_at,
         to: :pay_subscription
 
       def initialize(pay_subscription)

data/lib/pay/stripe/webhooks/payment_intent_succeeded.rb

@@ -0,0 +1,27 @@
+module Pay
+  module Stripe
+    module Webhooks
+      class PaymentIntentSucceeded
+        def call(event)
+          object = event.data.object
+          billable = Pay.find_billable(processor: :stripe, processor_id: object.customer)
+
+          return unless billable.present?
+
+          object.charges.data.each do |charge|
+            next if billable.charges.where(processor_id: charge.id).any?
+
+            charge = Pay::Stripe::Billable.new(billable).save_pay_charge(charge)
+            notify_user(billable, charge)
+          end
+        end
+
+        def notify_user(billable, charge)
+          if Pay.send_emails && charge.respond_to?(:receipt)
+            Pay::UserMailer.with(billable: billable, charge: charge).receipt.deliver_later
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pay/stripe_marketplace/billable.rb

@@ -0,0 +1,246 @@
+module Pay
+  module StripeMarketplace
+    class Billable
+      include Rails.application.routes.url_helpers
+
+      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 customer
+        if processor_id?
+          ::Stripe::Customer.retrieve(processor_id)
+        else
+          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
+
+      # Handles Billable#charge
+      #
+      # Returns Pay::Charge
+      def charge(amount, options = {})
+        stripe_customer = customer
+        args = {
+          amount: amount,
+          confirm: true,
+          confirmation_method: :automatic,
+          currency: "usd",
+          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
+        save_pay_charge(payment_intent.charges.first)
+      rescue ::Stripe::StripeError => e
+        raise Pay::Stripe::Error, e
+      end
+
+      # Handles Billable#subscribe
+      #
+      # Returns Pay::Subscription
+      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"],
+          items: [plan: plan, quantity: quantity],
+          off_session: true
+        }.merge(options)
+
+        # Inherit trial from plan unless trial override was specified
+        opts[:trial_from_plan] = true unless opts[:trial_period_days]
+
+        opts[:customer] = customer.id
+
+        stripe_sub = ::Stripe::Subscription.create(opts)
+        subscription = billable.create_pay_subscription(stripe_sub, "stripe", name, plan, status: stripe_sub.status, quantity: quantity)
+
+        # No trial, card requires SCA
+        if subscription.incomplete?
+          Pay::Payment.new(stripe_sub.latest_invoice.payment_intent).validate
+
+        # Trial, card requires SCA
+        elsif subscription.on_trial? && stripe_sub.pending_setup_intent
+          Pay::Payment.new(stripe_sub.pending_setup_intent).validate
+        end
+
+        subscription
+      rescue ::Stripe::StripeError => e
+        raise Pay::Stripe::Error, e
+      end
+
+      # Handles Billable#update_card
+      #
+      # Returns true if successful
+      def update_card(payment_method_id)
+        stripe_customer = customer
+
+        return true if payment_method_id == stripe_customer.invoice_settings.default_payment_method
+
+        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_card_on_file(payment_method.card)
+        true
+      rescue ::Stripe::StripeError => e
+        raise Pay::Stripe::Error, e
+      end
+
+      def update_email!
+        ::Stripe::Customer.update(processor_id, {email: email, name: customer_name})
+      end
+
+      def processor_subscription(subscription_id, options = {})
+        ::Stripe::Subscription.retrieve(options.merge(id: subscription_id))
+      end
+
+      def invoice!(options = {})
+        return unless processor_id?
+        ::Stripe::Invoice.create(options.merge(customer: processor_id)).pay
+      end
+
+      def upcoming_invoice
+        ::Stripe::Invoice.upcoming(customer: processor_id)
+      end
+
+      # Used by webhooks when the customer or source changes
+      def sync_card_from_stripe
+        if (payment_method_id = customer.invoice_settings.default_payment_method)
+          update_card_on_file ::Stripe::PaymentMethod.retrieve(payment_method_id).card
+        else
+          billable.update(card_type: nil, card_last4: nil)
+        end
+      end
+
+      def create_setup_intent
+        ::Stripe::SetupIntent.create(customer: processor_id, usage: :off_session)
+      end
+
+      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_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
+        )
+
+        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
+end