pay 2.7.0 → 3.0.1

data/lib/pay/paddle.rb

@@ -2,8 +2,9 @@ module Pay
   module Paddle
     autoload :Billable, "pay/paddle/billable"
     autoload :Charge, "pay/paddle/charge"
-    autoload :Subscription, "pay/paddle/subscription"
     autoload :Error, "pay/paddle/error"
+    autoload :PaymentMethod, "pay/paddle/payment_method"
+    autoload :Subscription, "pay/paddle/subscription"
 
     module Webhooks
       autoload :SignatureVerifier, "pay/paddle/webhooks/signature_verifier"
@@ -44,9 +45,12 @@ module Pay
       options.merge(owner_sgid: owner.to_sgid.to_s).to_json
     end
 
+    def self.parse_passthrough(passthrough)
+      JSON.parse(passthrough)
+    end
+
     def self.owner_from_passthrough(passthrough)
-      passthrough_json = JSON.parse(passthrough)
-      GlobalID::Locator.locate_signed(passthrough_json["owner_sgid"])
+      GlobalID::Locator.locate_signed parse_passthrough(passthrough)["owner_sgid"]
     rescue JSON::ParserError
       nil
     end

data/lib/pay/payment.rb

@@ -2,7 +2,7 @@ module Pay
   class Payment
     attr_reader :intent
 
-    delegate :id, :amount, :client_secret, :status, :confirm, to: :intent
+    delegate :id, :amount, :client_secret, :customer, :status, :confirm, to: :intent
 
     def self.from_id(id)
       intent = id.start_with?("seti_") ? ::Stripe::SetupIntent.retrieve(id) : ::Stripe::PaymentIntent.retrieve(id)

data/lib/pay/receipts.rb

@@ -1,14 +1,14 @@
 module Pay
   module Receipts
-    def filename
-      "receipt-#{created_at.strftime("%Y-%m-%d")}.pdf"
-    end
-
     def product
       Pay.application_name
     end
 
-    # Must return a file object
+    def receipt_filename
+      "receipt-#{created_at.strftime("%Y-%m-%d")}.pdf"
+    end
+    alias_method :filename, :receipt_filename
+
     def receipt
       receipt_pdf.render
     end
@@ -26,15 +26,43 @@ module Pay
       )
     end
 
+    def invoice_filename
+      "invoice-#{created_at.strftime("%Y-%m-%d")}.pdf"
+    end
+
+    def invoice
+      invoice_pdf.render
+    end
+
+    def invoice_pdf
+      ::Receipts::Invoice.new(
+        id: id,
+        issue_date: created_at,
+        due_date: created_at,
+        status: "<b><color rgb='#5eba7d'>PAID</color></b>",
+        bill_to: [
+          customer.customer_name,
+          customer.email
+        ].compact,
+        product: product,
+        company: {
+          name: Pay.business_name,
+          address: Pay.business_address,
+          email: Pay.support_email
+        },
+        line_items: line_items
+      )
+    end
+
     def line_items
       line_items = [
         [I18n.t("receipt.date"), created_at.to_s],
-        [I18n.t("receipt.account_billed"), "#{owner.name} (#{owner.email})"],
+        [I18n.t("receipt.account_billed"), "#{customer.customer_name} (#{customer.email})"],
         [I18n.t("receipt.product"), product],
         [I18n.t("receipt.amount"), ActionController::Base.helpers.number_to_currency(amount / 100.0)],
         [I18n.t("receipt.charged_to"), charged_to]
       ]
-      line_items << [I18n.t("receipt.additional_info"), owner.extra_billing_info] if owner.extra_billing_info?
+      line_items << [I18n.t("receipt.additional_info"), customer.owner.extra_billing_info] if customer.owner.extra_billing_info?
       line_items
     end
   end

data/lib/pay/stripe/billable.rb

@@ -3,43 +3,40 @@ module Pay
     class Billable
       include Rails.application.routes.url_helpers
 
-      attr_reader :billable
+      attr_reader :pay_customer
 
       delegate :processor_id,
         :processor_id?,
         :email,
         :customer_name,
-        :card_token,
+        :payment_method_token,
+        :payment_method_token?,
         :stripe_account,
-        to: :billable
+        to: :pay_customer
 
-      class << self
-        def default_url_options
-          Rails.application.config.action_mailer.default_url_options || {}
-        end
+      def self.default_url_options
+        Rails.application.config.action_mailer.default_url_options || {}
       end
 
-      def initialize(billable)
-        @billable = billable
+      def initialize(pay_customer)
+        @pay_customer = pay_customer
       end
 
-      # Handles Billable#customer
-      #
-      # Returns Stripe::Customer
       def customer
         stripe_customer = if processor_id?
-          ::Stripe::Customer.retrieve(processor_id, {stripe_account: stripe_account})
+          ::Stripe::Customer.retrieve({id: processor_id}, stripe_options)
         else
-          sc = ::Stripe::Customer.create({email: email, name: customer_name}, {stripe_account: stripe_account})
-          billable.update(processor: :stripe, processor_id: sc.id, stripe_account: stripe_account)
+          sc = ::Stripe::Customer.create({email: email, name: customer_name}, stripe_options)
+          pay_customer.update!(processor_id: sc.id, stripe_account: stripe_account)
           sc
         end
 
-        # 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_account: stripe_account})
-          stripe_customer = ::Stripe::Customer.update(stripe_customer.id, {invoice_settings: {default_payment_method: payment_method.id}}, {stripe_account: stripe_account})
-          update_card_on_file(payment_method.card)
+        if payment_method_token?
+          payment_method = ::Stripe::PaymentMethod.attach(payment_method_token, {customer: stripe_customer.id}, stripe_options)
+          pay_payment_method = save_payment_method(payment_method, default: false)
+          pay_payment_method.make_default!
+
+          pay_customer.payment_method_token = nil
         end
 
         stripe_customer
@@ -47,36 +44,32 @@ module Pay
         raise Pay::Stripe::Error, e
       end
 
-      # Handles Billable#charge
-      #
-      # Returns Pay::Charge
       def charge(amount, options = {})
-        stripe_customer = customer
+        add_payment_method(payment_method_token, default: true) if payment_method_token?
+
+        payment_method = pay_customer.default_payment_method
         args = {
           amount: amount,
           confirm: true,
           confirmation_method: :automatic,
           currency: "usd",
-          customer: stripe_customer.id,
-          payment_method: stripe_customer.invoice_settings.default_payment_method
+          customer: processor_id,
+          payment_method: payment_method&.processor_id
         }.merge(options)
 
-        payment_intent = ::Stripe::PaymentIntent.create(args, {stripe_account: stripe_account})
+        payment_intent = ::Stripe::PaymentIntent.create(args, stripe_options)
         Pay::Payment.new(payment_intent).validate
 
-        # Create a new charge object
-        save_pay_charge(payment_intent.charges.first)
+        charge = payment_intent.charges.first
+        Pay::Stripe::Charge.sync(charge.id, object: charge)
       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"],
+          expand: ["pending_setup_intent", "latest_invoice.payment_intent", "latest_invoice.charge.invoice"],
           items: [plan: plan, quantity: quantity],
           off_session: true
         }.merge(options)
@@ -84,19 +77,18 @@ module Pay
         # Inherit trial from plan unless trial override was specified
         opts[:trial_from_plan] = true unless opts[:trial_period_days]
 
-        # Load the Stripe customer to verify it exists and update card if needed
+        # Load the Stripe customer to verify it exists and update payment method if needed
         opts[:customer] = customer.id
 
-        stripe_sub = ::Stripe::Subscription.create(opts, {stripe_account: stripe_account})
-        subscription = billable.create_pay_subscription(stripe_sub, "stripe", name, plan, status: stripe_sub.status, quantity: quantity, stripe_account: stripe_account, application_fee_percent: stripe_sub.application_fee_percent)
+        # Create subscription on Stripe
+        stripe_sub = ::Stripe::Subscription.create(opts, stripe_options)
 
-        # No trial, card requires SCA
+        # Save Pay::Subscription
+        subscription = Pay::Stripe::Subscription.sync(stripe_sub.id, object: stripe_sub, name: name)
+
+        # No trial, payment method 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
@@ -104,51 +96,57 @@ module Pay
         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
+      def add_payment_method(payment_method_id, default: false)
+        customer unless processor_id?
+        payment_method = ::Stripe::PaymentMethod.attach(payment_method_id, {customer: processor_id}, stripe_options)
 
-        payment_method = ::Stripe::PaymentMethod.attach(payment_method_id, {customer: stripe_customer.id}, {stripe_account: stripe_account})
-        ::Stripe::Customer.update(stripe_customer.id, {invoice_settings: {default_payment_method: payment_method.id}}, {stripe_account: stripe_account})
+        if default
+          ::Stripe::Customer.update(processor_id, {
+            invoice_settings: {
+              default_payment_method: payment_method.id
+            }
+          }, stripe_options)
+        end
 
-        update_card_on_file(payment_method.card)
-        true
+        save_payment_method(payment_method, default: default)
       rescue ::Stripe::StripeError => e
         raise Pay::Stripe::Error, e
       end
 
+      # Save the Stripe::PaymentMethod to the database
+      def save_payment_method(payment_method, default:)
+        pay_payment_method = pay_customer.payment_methods.where(processor_id: payment_method.id).first_or_initialize
+
+        attributes = Pay::Stripe::PaymentMethod.extract_attributes(payment_method).merge(default: default)
+
+        pay_customer.payment_methods.update_all(default: false) if default
+        pay_payment_method.update!(attributes)
+
+        # Reload the Rails association
+        pay_customer.reload_default_payment_method if default
+
+        pay_payment_method
+      end
+
       def update_email!
-        ::Stripe::Customer.update(processor_id, {email: email, name: customer_name}, {stripe_account: stripe_account})
+        ::Stripe::Customer.update(processor_id, {email: email, name: customer_name}, stripe_options)
       end
 
       def processor_subscription(subscription_id, options = {})
-        ::Stripe::Subscription.retrieve(options.merge(id: subscription_id), {stripe_account: stripe_account})
+        ::Stripe::Subscription.retrieve(options.merge(id: subscription_id), stripe_options)
       end
 
       def invoice!(options = {})
         return unless processor_id?
-        ::Stripe::Invoice.create(options.merge(customer: processor_id), {stripe_account: stripe_account}).pay
+        ::Stripe::Invoice.create(options.merge(customer: processor_id), stripe_options).pay
       end
 
       def upcoming_invoice
-        ::Stripe::Invoice.upcoming({customer: processor_id}, {stripe_account: stripe_account})
-      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, {stripe_account: stripe_account}).card
-        else
-          billable.update(card_type: nil, card_last4: nil)
-        end
+        ::Stripe::Invoice.upcoming({customer: processor_id}, stripe_options)
       end
 
       def create_setup_intent
-        ::Stripe::SetupIntent.create({customer: processor_id, usage: :off_session}, {stripe_account: stripe_account})
+        ::Stripe::SetupIntent.create({customer: processor_id, usage: :off_session}, stripe_options)
       end
 
       def trial_end_date(stripe_sub)
@@ -156,41 +154,14 @@ module Pay
         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)
-
-        attrs = {
-          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),
-          currency: object.currency,
-          stripe_account: stripe_account,
-          application_fee_amount: object.application_fee_amount
-        }
-
-        # Associate charge with subscription if we can
-        if object.invoice
-          invoice = (object.invoice.is_a?(::Stripe::Invoice) ? object.invoice : ::Stripe::Invoice.retrieve(object.invoice))
-          attrs[:subscription] = Pay::Subscription.find_by(processor: :stripe, processor_id: invoice.subscription)
+      # Syncs a customer's subscriptions from Stripe to the database
+      def sync_subscriptions
+        subscriptions = ::Stripe::Subscription.list({customer: customer}, stripe_options)
+        subscriptions.map do |subscription|
+          Pay::Stripe::Subscription.sync(subscription.id)
         end
-
-        charge.update(attrs)
-        charge
+      rescue ::Stripe::StripeError => e
+        raise Pay::Stripe::Error, e
       end
 
       # https://stripe.com/docs/api/checkout/sessions/create
@@ -224,7 +195,7 @@ module Pay
           }
         end
 
-        ::Stripe::Checkout::Session.create(args.merge(options), {stripe_account: stripe_account})
+        ::Stripe::Checkout::Session.create(args.merge(options), stripe_options)
       end
 
       # https://stripe.com/docs/api/checkout/sessions/create
@@ -251,7 +222,14 @@ module Pay
           customer: processor_id,
           return_url: options.delete(:return_url) || root_url
         }
-        ::Stripe::BillingPortal::Session.create(args.merge(options), {stripe_account: stripe_account})
+        ::Stripe::BillingPortal::Session.create(args.merge(options), stripe_options)
+      end
+
+      private
+
+      # Options for Stripe requests
+      def stripe_options
+        {stripe_account: stripe_account}.compact
       end
     end
   end

data/lib/pay/stripe/charge.rb

@@ -3,14 +3,63 @@ module Pay
     class Charge
       attr_reader :pay_charge
 
-      delegate :processor_id, :owner, :stripe_account, to: :pay_charge
+      delegate :processor_id, :stripe_account, to: :pay_charge
+
+      def self.sync(charge_id, object: nil, stripe_account: nil, try: 0, retries: 1)
+        # Skip loading the latest charge details from the API if we already have it
+        object ||= ::Stripe::Charge.retrieve(charge_id, {stripe_account: stripe_account}.compact)
+
+        pay_customer = Pay::Customer.find_by(processor: :stripe, processor_id: object.customer)
+        return unless pay_customer
+
+        payment_method = object.payment_method_details.send(object.payment_method_details.type)
+        attrs = {
+          amount: object.amount,
+          amount_refunded: object.amount_refunded,
+          application_fee_amount: object.application_fee_amount,
+          created_at: Time.at(object.created),
+          currency: object.currency,
+          stripe_account: pay_customer.stripe_account,
+          metadata: object.metadata,
+          payment_method_type: object.payment_method_details.type,
+          brand: payment_method.try(:brand)&.capitalize,
+          last4: payment_method.try(:last4).to_s,
+          exp_month: payment_method.try(:exp_month).to_s,
+          exp_year: payment_method.try(:exp_year).to_s,
+          bank: payment_method.try(:bank_name) || payment_method.try(:bank) # eps, fpx, ideal, p24, acss_debit, etc
+        }
+
+        # Associate charge with subscription if we can
+        if object.invoice
+          invoice = (object.invoice.is_a?(::Stripe::Invoice) ? object.invoice : ::Stripe::Invoice.retrieve(object.invoice, {stripe_account: stripe_account}.compact))
+          attrs[:subscription] = pay_customer.subscriptions.find_by(processor_id: invoice.subscription)
+        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
+      rescue ActiveRecord::RecordInvalid
+        try += 1
+        if try <= retries
+          sleep 0.1
+          retry
+        else
+          raise
+        end
+      end
 
       def initialize(pay_charge)
         @pay_charge = pay_charge
       end
 
       def charge
-        ::Stripe::Charge.retrieve({id: processor_id, expand: ["customer", "invoice.subscription"]}, {stripe_account: stripe_account})
+        ::Stripe::Charge.retrieve({id: processor_id, expand: ["customer", "invoice.subscription"]}, stripe_options)
       rescue ::Stripe::StripeError => e
         raise Pay::Stripe::Error, e
       end
@@ -21,11 +70,18 @@ module Pay
       # refund!(5_00)
       # refund!(5_00, refund_application_fee: true)
       def refund!(amount_to_refund, **options)
-        ::Stripe::Refund.create(options.merge(charge: processor_id, amount: amount_to_refund), {stripe_account: stripe_account})
+        ::Stripe::Refund.create(options.merge(charge: processor_id, amount: amount_to_refund), stripe_options)
         pay_charge.update(amount_refunded: amount_to_refund)
       rescue ::Stripe::StripeError => e
         raise Pay::Stripe::Error, e
       end
+
+      private
+
+      # Options for Stripe requests
+      def stripe_options
+        {stripe_account: stripe_account}.compact
+      end
     end
   end
 end