spree_stripe 1.0.2

data/app/presenters/spree_stripe/customer_presenter.rb

@@ -0,0 +1,35 @@
+module SpreeStripe
+  class CustomerPresenter
+    def initialize(address: nil, email: nil, name: nil)
+      @email = email
+      @name = name
+      @address = address
+    end
+
+    def call
+      hash = {}
+      hash[:address] = address_payload if address.present?
+      hash[:email] = email if email.present?
+      hash[:name] = name if name.present?
+
+      hash
+    end
+
+    private
+
+    attr_reader :email, :name, :address
+
+    def address_payload
+      return {} unless address
+
+      {
+        city: address.city,
+        line1: address.address1,
+        line2: address.address2,
+        postal_code: address.zipcode,
+        country: address.country_name,
+        state: address.state_name
+      }
+    end
+  end
+end

data/app/presenters/spree_stripe/payment_intent_presenter.rb

@@ -0,0 +1,103 @@
+module SpreeStripe
+  class PaymentIntentPresenter
+    SETUP_FUTURE_USAGE = 'off_session'
+    STATEMENT_DESCRIPTOR_MAX_CHARACTERS = 22
+
+    def initialize(amount:, order:, customer: nil, payment_method_id: nil, off_session: false)
+      @amount = amount
+      @order = order
+      @customer = customer
+      @ship_address = order.ship_address
+      @payment_method_id = payment_method_id
+      @off_session = off_session
+    end
+
+    def call
+      payload = if payment_method_id.present?
+                  saved_payment_method_payload
+                else
+                  new_payment_method_payload
+                end
+
+      payload = payload.deep_merge(basic_payload)
+
+      return payload unless ship_address
+
+      # we don't validate address1, but it's required by Stripe
+      if ship_address.invalid? || ship_address.address1.blank?
+        ship_address.errors.clear
+        return payload
+      end
+
+      payload.merge(ship_address_payload)
+    end
+
+    def ship_address_payload
+      {
+        shipping: {
+          address: {
+            city: ship_address.city,
+            country: ship_address.country_iso,
+            line1: ship_address.address1,
+            line2: ship_address.address2,
+            postal_code: ship_address.zipcode,
+            state: ship_address.state_abbr
+          },
+          name: ship_address.full_name
+        }
+      }
+    end
+
+    private
+
+    def basic_payload
+      {
+        amount: amount,
+        customer: customer,
+        currency: order.currency,
+        statement_descriptor_suffix: statement_descriptor,
+        automatic_payment_methods: {
+          enabled: true
+        },
+        transfer_group: order.number,
+        metadata: {
+          spree_order_id: order.id
+        }
+      }
+    end
+
+    def statement_descriptor
+      billing_name = order.store.billing_name
+      descriptor = "#{order.number} #{billing_name}".strip
+
+      if descriptor.length > STATEMENT_DESCRIPTOR_MAX_CHARACTERS
+        additional_char_count = descriptor.length - STATEMENT_DESCRIPTOR_MAX_CHARACTERS + 1
+        short_billing_name = billing_name[0...-additional_char_count]
+
+        descriptor = "#{order.number} #{short_billing_name}".strip
+      end
+
+      descriptor
+    end
+
+    def new_payment_method_payload
+      {
+        payment_method_options: {
+          card: {
+            setup_future_usage: SETUP_FUTURE_USAGE
+          }
+        }
+      }
+    end
+
+    def saved_payment_method_payload
+      {
+        payment_method: payment_method_id,
+        off_session: @off_session,
+        confirm: @off_session # confirm is required for off_session payments
+      }
+    end
+
+    attr_reader :order, :amount, :customer, :ship_address, :payment_method_id
+  end
+end

data/app/serializers/spree/api/v2/platform/affirm_serializer.rb

@@ -0,0 +1,9 @@
+module Spree
+  module Api
+    module V2
+      module Platform
+        class AffirmSerializer < PaymentSourceSerializer; end
+      end
+    end
+  end
+end

data/app/serializers/spree/api/v2/platform/after_pay_serializer.rb

@@ -0,0 +1,9 @@
+module Spree
+  module Api
+    module V2
+      module Platform
+        class AfterPaySerializer < PaymentSourceSerializer; end
+      end
+    end
+  end
+end

data/app/serializers/spree/api/v2/platform/alipay_serializer.rb

@@ -0,0 +1,9 @@
+module Spree
+  module Api
+    module V2
+      module Platform
+        class AlipaySerializer < PaymentSourceSerializer; end
+      end
+    end
+  end
+end

data/app/serializers/spree/api/v2/platform/ideal_serializer.rb

@@ -0,0 +1,9 @@
+module Spree
+  module Api
+    module V2
+      module Platform
+        class IdealSerializer < PaymentSourceSerializer; end
+      end
+    end
+  end
+end

data/app/serializers/spree/api/v2/platform/klarna_serializer.rb

@@ -0,0 +1,9 @@
+module Spree
+  module Api
+    module V2
+      module Platform
+        class KlarnaSerializer < PaymentSourceSerializer; end
+      end
+    end
+  end
+end

data/app/serializers/spree/api/v2/platform/link_serializer.rb

@@ -0,0 +1,9 @@
+module Spree
+  module Api
+    module V2
+      module Platform
+        class LinkSerializer < PaymentSourceSerializer; end
+      end
+    end
+  end
+end

data/app/serializers/spree/api/v2/platform/przelewy24_serializer.rb

@@ -0,0 +1,9 @@
+module Spree
+  module Api
+    module V2
+      module Platform
+        class Przelewy24Serializer < PaymentSourceSerializer; end
+      end
+    end
+  end
+end

data/app/serializers/spree/api/v2/platform/sepa_debit_serializer.rb

@@ -0,0 +1,9 @@
+module Spree
+  module Api
+    module V2
+      module Platform
+        class SepaDebitSerializer < PaymentSourceSerializer; end
+      end
+    end
+  end
+end

data/app/serializers/spree/v2/storefront/affirm_serializer.rb

@@ -0,0 +1,7 @@
+module Spree
+  module V2
+    module Storefront
+      class AffirmSerializer < PaymentSourceSerializer; end
+    end
+  end
+end

data/app/serializers/spree/v2/storefront/after_pay_serializer.rb

@@ -0,0 +1,7 @@
+module Spree
+  module V2
+    module Storefront
+      class AfterPaySerializer < PaymentSourceSerializer; end
+    end
+  end
+end

data/app/serializers/spree/v2/storefront/alipay_serializer.rb

@@ -0,0 +1,7 @@
+module Spree
+  module V2
+    module Storefront
+      class AlipaySerializer < PaymentSourceSerializer; end
+    end
+  end
+end

data/app/serializers/spree/v2/storefront/ideal_serializer.rb

@@ -0,0 +1,7 @@
+module Spree
+  module V2
+    module Storefront
+      class IdealSerializer < PaymentSourceSerializer; end
+    end
+  end
+end

data/app/serializers/spree/v2/storefront/klarna_serializer.rb

@@ -0,0 +1,7 @@
+module Spree
+  module V2
+    module Storefront
+      class KlarnaSerializer < PaymentSourceSerializer; end
+    end
+  end
+end

data/app/serializers/spree/v2/storefront/link_serializer.rb

@@ -0,0 +1,7 @@
+module Spree
+  module V2
+    module Storefront
+      class LinkSerializer < PaymentSourceSerializer; end
+    end
+  end
+end

data/app/serializers/spree/v2/storefront/payment_intent_serializer.rb

@@ -0,0 +1,11 @@
+module Spree
+  module V2
+    module Storefront
+      class PaymentIntentSerializer < BaseSerializer
+        set_type :payment_intent
+
+        attributes :stripe_id, :client_secret, :ephemeral_key_secret, :customer_id, :amount, :stripe_payment_method_id
+      end
+    end
+  end
+end

data/app/serializers/spree/v2/storefront/przelewy24_serializer.rb

@@ -0,0 +1,7 @@
+module Spree
+  module V2
+    module Storefront
+      class Przelewy24Serializer < PaymentSourceSerializer; end
+    end
+  end
+end

data/app/serializers/spree/v2/storefront/sepa_debit_serializer.rb

@@ -0,0 +1,7 @@
+module Spree
+  module V2
+    module Storefront
+      class SepaDebitSerializer < PaymentSourceSerializer; end
+    end
+  end
+end

data/app/services/spree_stripe/complete_order.rb

@@ -0,0 +1,99 @@
+module SpreeStripe
+  class CompleteOrder
+    def initialize(payment_intent:)
+      @payment_intent = payment_intent
+    end
+
+    attr_reader :payment_intent
+
+    def call
+      order = payment_intent.order
+
+      return order if order.completed? || order.canceled?
+
+      charge = payment_intent.stripe_charge
+
+      order.with_lock do
+        # needed for quick checkout orders
+        order = add_customer_information(order, charge)
+
+        # find or create the payment
+        payment = payment_intent.find_or_create_payment!
+
+        # process the payment
+        payment.process!
+
+        # complete the order
+        Spree::Dependencies.checkout_complete_service.constantize.call(order: order)
+      end
+
+      order.reload
+    end
+
+    private
+
+    # we need to perform this for quick checkout orders which do not have these fields filled
+    def add_customer_information(order, charge)
+      billing_details = charge.billing_details
+      address = billing_details.address
+
+      order.email ||= billing_details.email
+      order.save! if order.email_changed?
+
+      # we don't need to perform this if we already have the billing address filled
+      return order if order.bill_address.present? && order.bill_address.valid?
+
+      # determine country...
+      country_iso = address.country
+      country = Spree::Country.find_by(iso: country_iso) || Spree::Country.default
+
+      # assign new address if we don't have one
+      order.bill_address ||= Spree::Address.new(country: country, user: order.user)
+
+      # assign attributes
+      order.bill_address.quick_checkout = true # skipping some validations
+
+      # sometimes google pay doesn't provide name (geez)
+      first_name = billing_details.name&.split(' ')&.first || order.ship_address&.first_name || order.user&.first_name
+      last_name = billing_details.name&.split(' ')&.last || order.ship_address&.last_name || order.user&.last_name
+
+      order.bill_address.first_name ||= first_name
+      order.bill_address.last_name ||= last_name
+      order.bill_address.phone ||= billing_details.phone
+      order.bill_address.address1 ||= address.line1
+      order.bill_address.address2 ||= address.line2
+      order.bill_address.city ||= address.city
+      order.bill_address.zipcode ||= address.postal_code
+
+      state_name = address.state
+      if country.states_required?
+        order.bill_address.state = country.states.find_all_by_name_or_abbr(state_name)&.first if country.states_required?
+      else
+        order.bill_address.state_name = state_name
+      end
+
+      order.bill_address.state_name ||= state_name
+
+      if order.bill_address.invalid?
+        order.bill_address = order.ship_address
+      else
+        order.bill_address.save!
+      end
+
+      order.save!
+
+      copy_bill_info_to_user(order) if order.user.present?
+
+      order
+    end
+
+    def copy_bill_info_to_user(order)
+      user = order.user
+      user.first_name ||= order.bill_address.first_name
+      user.last_name ||= order.bill_address.last_name
+      user.phone ||= order.bill_address.phone
+      user.bill_address_id ||= order.bill_address.id
+      user.save! if user.changed?
+    end
+  end
+end

data/app/services/spree_stripe/create_gateway_webhooks.rb

@@ -0,0 +1,55 @@
+module SpreeStripe
+  class CreateGatewayWebhooks
+    def call(payment_method:, events: SpreeStripe::Config[:supported_webhook_events], connect: false)
+      webhook_list = Stripe::WebhookEndpoint.list({}, { api_key: payment_method.preferred_secret_key })
+      webhook = find_webhook(webhook_list[:data], events)
+
+      ensure_webhook(payment_method, webhook, connect, events)
+    end
+
+    private
+
+    def find_webhook(webhooks_data, enabled_events)
+      webhook_url = SpreeStripe::Gateway.webhook_url
+
+      webhooks_data.find do |webhook|
+        webhook[:url] == webhook_url && webhook[:enabled_events].sort == enabled_events.sort
+      end
+    end
+
+    def ensure_webhook(payment_method, stripe_webhook, connect, events)
+      if stripe_webhook.nil?
+        create_webhook_endpoint(payment_method, connect, events)
+      else
+        webhook_key = WebhookKey.find_by(stripe_id: stripe_webhook[:id])
+
+        if webhook_key.present?
+          webhook_key.payment_methods << payment_method if webhook_key.payment_methods.exclude?(payment_method)
+        else
+          create_webhook_endpoint(payment_method, connect, events)
+        end
+      end
+    end
+
+    def create_webhook_endpoint(payment_method, connect, events)
+      params = build_webhook_params(connect, events)
+      stripe_webhook = Stripe::WebhookEndpoint.create(params, { api_key: payment_method.preferred_secret_key })
+
+      SpreeStripe::WebhookKey.create!(
+        stripe_id: stripe_webhook[:id],
+        signing_secret: stripe_webhook[:secret],
+        payment_methods: [payment_method]
+      )
+
+      Rails.cache.delete('stripe_webhook_signing_keys')
+    end
+
+    def build_webhook_params(connect, events)
+      {
+        url: SpreeStripe::Gateway.webhook_url,
+        enabled_events: events,
+        connect: connect
+      }
+    end
+  end
+end

data/app/services/spree_stripe/create_payment.rb

@@ -0,0 +1,43 @@
+module SpreeStripe
+  class CreatePayment
+    def initialize(order:, payment_intent:, gateway: nil, tax_transaction: nil, amount: nil)
+      @order = order
+      @gateway = gateway || order.store.stripe_gateway
+      @payment_intent = payment_intent
+      @tax_transaction = tax_transaction
+      @amount = amount || order.total_minus_store_credits
+    end
+
+    def call
+      stripe_charge = payment_intent.stripe_charge
+
+      if stripe_charge.present?
+        source = SpreeStripe::CreateSource.new(
+          order: order,
+          stripe_payment_method_details: stripe_charge.payment_method_details,
+          stripe_payment_method_id: stripe_charge.payment_method,
+          stripe_billing_details: stripe_charge.billing_details,
+          gateway: gateway
+        ).call
+      end
+
+      # sometimes a job is re-tried and creates a double payment record so we need to avoid it!
+      payment = order.payments.find_or_initialize_by(
+        payment_method_id: gateway.id,
+        response_code: payment_intent.stripe_id,
+        amount: amount
+      )
+
+      payment.source = source if source.present?
+      payment.stripe_tax_transaction_id = tax_transaction
+      payment.stripe_charge_id = stripe_charge&.id
+
+      payment.save!
+      payment
+    end
+
+    private
+
+    attr_reader :order, :gateway, :payment_intent, :tax_transaction, :source, :amount
+  end
+end

data/app/services/spree_stripe/create_payment_intent.rb

@@ -0,0 +1,40 @@
+module SpreeStripe
+  class CreatePaymentIntent
+    def call(order, gateway, stripe_payment_method_id: nil, off_session: false)
+      total = order.total_minus_store_credits
+      amount = Spree::Money.new(total).cents
+
+      return nil if amount.zero?
+
+      # lookup in database for existing payment intent
+      payment_intent = SpreeStripe::PaymentIntent.find_by(order: order, payment_method: gateway)
+
+      return payment_intent if payment_intent.present?
+
+      # response is an ActiveMerchant::Billing::Response object
+      # https://github.com/activemerchant/active_merchant/blob/master/lib/active_merchant/billing/response.rb
+      response = gateway.create_payment_intent(
+        amount,
+        order,
+        payment_method_id: stripe_payment_method_id,
+        off_session: off_session
+      )
+
+      # we should only create a customer if the order was placed by a user
+      customer = gateway.fetch_or_create_customer(user: order.user) if order.user.present?
+      ephemeral_key_response = gateway.create_ephemeral_key(customer.profile_id) if customer.present?
+      ephemeral_key_secret = ephemeral_key_response&.params['secret'] if ephemeral_key_response.present?
+
+      # persist the payment intent
+      SpreeStripe::PaymentIntent.create!(
+        order: order,
+        payment_method: gateway,
+        amount: total,
+        stripe_id: response.authorization,
+        client_secret: response.params['client_secret'],
+        customer_id: customer&.profile_id,
+        ephemeral_key_secret: ephemeral_key_secret
+      )
+    end
+  end
+end

data/app/services/spree_stripe/create_setup_intent.rb

@@ -0,0 +1,20 @@
+module SpreeStripe
+  class CreateSetupIntent
+    prepend Spree::ServiceModule::Base
+
+    def call(gateway:, user:)
+      customer = gateway.fetch_or_create_customer(user: user)
+
+      ephemeral_key_response = gateway.create_ephemeral_key(customer.profile_id)
+      setup_intent = gateway.create_setup_intent(customer.profile_id)
+
+      success(
+        {
+          customer_id: customer.profile_id,
+          ephemeral_key_secret: ephemeral_key_response.params['secret'],
+          setup_intent_client_secret: setup_intent.params['client_secret']
+        }
+      )
+    end
+  end
+end

data/app/services/spree_stripe/create_source.rb

@@ -0,0 +1,87 @@
+module SpreeStripe
+  class CreateSource
+    def initialize(stripe_payment_method_details:, stripe_payment_method_id:, gateway:, stripe_billing_details:, order: nil, user: nil)
+      @stripe_payment_method_details = stripe_payment_method_details
+      @stripe_payment_method_id = stripe_payment_method_id
+      @gateway = gateway
+      @user = user || order&.user
+      @stripe_billing_details = stripe_billing_details
+      @order = order
+    end
+
+    def call
+      case stripe_payment_method_details.type
+      when 'card'
+        find_or_create_credit_card
+      when 'klarna'
+        SpreeStripe::PaymentSources::Klarna.create!(source_params)
+      when 'afterpay_clearpay'
+        SpreeStripe::PaymentSources::AfterPay.create!(source_params)
+      when 'sepa_debit'
+        SpreeStripe::PaymentSources::SepaDebit.create!(source_params)
+      when 'p24'
+        SpreeStripe::PaymentSources::Przelewy24.create!(source_params.merge(bank: stripe_payment_method_details.p24.bank))
+      when 'ideal'
+        SpreeStripe::PaymentSources::Ideal.create!(
+          source_params.merge(
+            bank: stripe_payment_method_details.ideal.bank,
+            last4: stripe_payment_method_details.ideal.iban_last4
+          )
+        )
+      when 'alipay'
+        SpreeStripe::PaymentSources::Alipay.create!(source_params)
+      when 'link'
+        SpreeStripe::PaymentSources::Link.create!(source_params)
+      when 'affirm'
+        SpreeStripe::PaymentSources::Affirm.create!(source_params)
+      else
+        raise "[STRIPE] Unknown payment method #{stripe_payment_method_details.type}"
+      end
+    end
+
+    private
+
+    attr_reader :gateway, :user, :stripe_payment_method_details, :stripe_payment_method_id, :stripe_billing_details, :order
+
+    def find_or_create_credit_card
+      if user
+        source = user.credit_cards.find_by(gateway_payment_profile_id: stripe_payment_method_id)
+
+        return source if source
+      end
+
+      Spree::CreditCard.create!(credit_card_params)
+    end
+
+    def credit_card_params
+      card_details = stripe_payment_method_details.card
+      customer = gateway.fetch_or_create_customer(user: user, order: order)
+
+      {
+        user: user,
+        gateway_customer: customer,
+        payment_method: gateway,
+        gateway_customer_profile_id: customer&.profile_id,
+        gateway_payment_profile_id: stripe_payment_method_id,
+        name: stripe_billing_details.name,
+        month: card_details.exp_month,
+        year: card_details.exp_year,
+        last_digits: card_details.last4,
+        brand: card_details.brand,
+        private_metadata: {
+          checks: stripe_payment_method_details.card&.checks,
+          wallet: {
+            type: stripe_payment_method_details.card&.wallet&.type
+          }
+        }
+      }
+    end
+
+    def source_params
+      {
+        gateway_payment_profile_id: stripe_payment_method_id,
+        payment_method: gateway
+      }
+    end
+  end
+end

data/app/services/spree_stripe/register_domain.rb

@@ -0,0 +1,22 @@
+module SpreeStripe
+  class RegisterDomain
+    def call(model:)
+      gateway = model.is_a?(Spree::Store) ? model.stripe_gateway : model.store.stripe_gateway
+
+      payment_method_domain = gateway.send_request { Stripe::PaymentMethodDomain.create({ domain_name: model.url }) }
+
+      attributes_to_update = { stripe_apple_pay_domain_id: payment_method_domain.id }
+
+      tld_length = model.url.split('.').length
+      if tld_length > 2 && model.is_a?(Spree::CustomDomain)
+        top_level_domain_name = model.url.split('.').last(tld_length - 1).join('.')
+        top_level_domain = gateway.send_request { Stripe::PaymentMethodDomain.create({ domain_name: top_level_domain_name }) }
+        attributes_to_update[:stripe_top_level_domain_id] = top_level_domain.id
+      end
+
+      model.update!(**attributes_to_update)
+
+      payment_method_domain
+    end
+  end
+end