solidus_stripe 4.4.0 → 5.0.0.alpha.1

data/app/assets/javascripts/spree/frontend/solidus_stripe/stripe-payment-request-button-shared.js

@@ -1,160 +0,0 @@
-// Shared code between Payment Intents and Payment Request Button on cart page
-
-(function() {
-  var PaymentRequestButtonShared;
-
-  PaymentRequestButtonShared = {
-    authToken: $('meta[name="csrf-token"]').attr('content'),
-
-    setUpPaymentRequest: function(opts) {
-      var opts = opts || {};
-      var config = this.config.payment_request;
-
-      if (config) {
-        config.requestShipping = opts.requestShipping || false;
-
-        var paymentRequest = this.stripe.paymentRequest({
-          country: config.country,
-          currency: config.currency,
-          total: {
-            label: config.label,
-            amount: config.amount
-          },
-          requestPayerName: true,
-          requestPayerEmail: true,
-          requestPayerPhone: true,
-          requestShipping: config.requestShipping,
-          shippingOptions: []
-        });
-
-        var prButton = this.elements.create('paymentRequestButton', {
-          paymentRequest: paymentRequest
-        });
-
-        var onButtonMount = function(result) {
-          var id = 'payment-request-button';
-
-          if (result) {
-            prButton.mount('#' + id);
-          } else {
-            document.getElementById(id).style.display = 'none';
-          }
-          if (typeof this.onPrButtonMounted === 'function') {
-            this.onPrButtonMounted(id, result);
-          }
-        }
-        paymentRequest.canMakePayment().then(onButtonMount.bind(this));
-
-        var onPrPaymentMethod = function(result) {
-          this.errorElement.text('').hide();
-          this.onPrPayment(result);
-        };
-        paymentRequest.on('paymentmethod', onPrPaymentMethod.bind(this));
-
-        var onShippingAddressChange = function(ev) {
-          var showError = this.showError.bind(this);
-
-          fetch('/stripe/shipping_rates', {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({
-              authenticity_token: this.authToken,
-              shipping_address: ev.shippingAddress
-            })
-          }).then(function(response) {
-            return response.json();
-          }).then(function(result) {
-            if (result.error) {
-              showError(result.error);
-              return false;
-            } else {
-              ev.updateWith({
-                status: 'success',
-                shippingOptions: result.shipping_rates
-              });
-            }
-          });
-        };
-        paymentRequest.on('shippingaddresschange', onShippingAddressChange.bind(this));
-      }
-    },
-
-    handleServerResponse: function(response, payment) {
-      if (response.error) {
-        this.showError(response.error);
-        this.completePaymentRequest(payment, 'fail');
-      } else if (response.requires_action) {
-        var clientSecret = response.stripe_payment_intent_client_secret;
-        var onConfirmCardPayment = this.onConfirmCardPayment.bind(this);
-
-        this.stripe.confirmCardPayment(
-          clientSecret,
-          {payment_method: payment.paymentMethod.id},
-          {handleActions: false}
-        ).then(function(confirmResult) {
-          onConfirmCardPayment(confirmResult, payment, clientSecret)
-        });
-      } else {
-        this.completePayment(payment, response.stripe_payment_intent_id)
-      }
-    },
-
-    onConfirmCardPayment: function(confirmResult, payment, clientSecret) {
-      onStripeResponse = function(response, payment) {
-        if (response.error) {
-          this.showError(response.error);
-        } else {
-          this.completePayment(payment, response.paymentIntent.id)
-        }
-      }.bind(this);
-
-      if (confirmResult.error) {
-        this.completePaymentRequest(payment, 'fail');
-        this.showError(confirmResult.error);
-      } else {
-        this.completePaymentRequest(payment, 'success');
-        this.stripe.confirmCardPayment(clientSecret).then(function(response) {
-          onStripeResponse(response, payment);
-        });
-      }
-    },
-
-    completePayment: function(payment, stripePaymentIntentId) {
-      var onCreateBackendPayment = function (response) {
-        if (response.error) {
-          this.completePaymentRequest(payment, 'fail');
-          this.showError(response.error);
-        } else {
-          this.completePaymentRequest(payment, 'success');
-          this.submitPayment(payment);
-        }
-      }.bind(this);
-
-      fetch('/stripe/create_payment', {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({
-          form_data: this.form ? this.form.serialize() : payment.shippingAddress,
-          spree_payment_method_id: this.config.id,
-          stripe_payment_intent_id: stripePaymentIntentId,
-          authenticity_token: this.authToken
-        })
-      }).then(function(solidusPaymentResponse) {
-        return solidusPaymentResponse.json();
-      }).then(onCreateBackendPayment)
-    },
-
-    completePaymentRequest: function(payment, state) {
-      if (payment && typeof payment.complete === 'function') {
-        payment.complete(state);
-        if (state === 'fail') {
-          // restart the button (required in order to force address choice)
-          new SolidusStripe.CartPageCheckout().init();
-        }
-      }
-    }
-  };
-
-  Object.assign(SolidusStripe.PaymentIntents.prototype, PaymentRequestButtonShared);
-  Object.assign(SolidusStripe.CartPageCheckout.prototype, PaymentRequestButtonShared);
-})()

data/app/assets/javascripts/spree/frontend/solidus_stripe/stripe-payment.js

@@ -1,16 +0,0 @@
-window.SolidusStripe = window.SolidusStripe || {};
-
-SolidusStripe.Payment = function() {
-  this.config = $('[data-stripe-config]').data('stripe-config');
-  this.element = $('#payment_method_' + this.config.id);
-  this.authToken = $('meta[name="csrf-token"]').attr('content');
-
-  this.stripe = Stripe(this.config.publishable_key);
-  this.elements = this.stripe.elements(this.elementsBaseOptions());
-};
-
-SolidusStripe.Payment.prototype.elementsBaseOptions = function () {
-  return {
-    locale: 'en'
-  };
-};

data/app/assets/javascripts/spree/frontend/solidus_stripe.js

@@ -1,6 +0,0 @@
-//= require ./solidus_stripe/stripe-payment
-//= require ./solidus_stripe/stripe-elements
-//= require ./solidus_stripe/stripe-payment-intents
-//= require ./solidus_stripe/stripe-cart-page-checkout
-//= require ./solidus_stripe/stripe-payment-request-button-shared
-//= require ./solidus_stripe/stripe-init

data/app/controllers/solidus_stripe/payment_request_controller.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-module SolidusStripe
-  class PaymentRequestController < Spree::BaseController
-    include Spree::Core::ControllerHelpers::Order
-
-    def shipping_rates
-      rates = SolidusStripe::ShippingRatesService.new(
-        current_order,
-        spree_current_user,
-        params[:shipping_address]
-      ).call
-
-      if rates.any?
-        render json: { success: true, shipping_rates: rates }
-      else
-        render json: { success: false, error: 'No shipping method available for that address' }, status: :internal_server_error
-      end
-    end
-
-    def update_order
-      current_order.restart_checkout_flow
-
-      address = SolidusStripe::AddressFromParamsService.new(
-        shipping_address_from_params,
-        spree_current_user
-      ).call
-
-      if address.valid?
-        SolidusStripe::PrepareOrderForPaymentService.new(address, self).call
-
-        if current_order.payment?
-          render json: { success: true }
-        else
-          render json: { success: false, error: 'Order not ready for payment. Try manual checkout.' }, status: :internal_server_error
-        end
-      else
-        render json: { success: false, error: address.errors.full_messages.to_sentence }, status: :internal_server_error
-      end
-    end
-
-    private
-
-    def shipping_address_from_params
-      return {} unless params[:shipping_address]
-      return params[:shipping_address] if params.dig(:shipping_address, :phone).present?
-
-      params[:shipping_address][:phone] = params[:phone]
-      params[:shipping_address]
-    end
-  end
-end

data/app/controllers/spree/stripe_controller.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-module Spree
-  class StripeController < SolidusStripe::IntentsController
-    include Core::ControllerHelpers::Order
-
-    def confirm_payment
-      Deprecation.warn "please use SolidusStripe::IntentsController#confirm"
-
-      confirm
-    end
-  end
-end

data/app/decorators/models/spree/order_update_attributes_decorator.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-module Spree
-  module OrderUpdateAttributesDecorator
-    def assign_payments_attributes
-      return if payments_attributes.empty?
-      return if adding_new_stripe_payment_intents_card?
-
-      stripe_intents_pending_payments.each(&:void_transaction!)
-
-      super
-    end
-
-    private
-
-    def adding_new_stripe_payment_intents_card?
-      paying_with_stripe_intents? && stripe_intents_pending_payments.any?
-    end
-
-    def stripe_intents_pending_payments
-      @stripe_intents_pending_payments ||= order.payments.valid.select do |payment|
-        payment_method = payment.payment_method
-        payment.pending? && stripe_intents?(payment_method)
-      end
-    end
-
-    def paying_with_stripe_intents?
-      if id = payments_attributes.first&.dig(:payment_method_id)
-        stripe_intents?(Spree::PaymentMethod.find(id))
-      end
-    end
-
-    def stripe_intents?(payment_method)
-      payment_method.respond_to?(:v3_intents?) && payment_method.v3_intents?
-    end
-
-    ::Spree::OrderUpdateAttributes.prepend(self)
-  end
-end

data/app/decorators/models/spree/payment_decorator.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-module Spree
-  module PaymentDecorator
-    def gateway_order_identifier
-      gateway_order_id
-    end
-
-    ::Spree::Payment.prepend(self)
-  end
-end

data/app/decorators/models/spree/refund_decorator.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-module Spree
-  module RefundDecorator
-    attr_reader :response
-
-    ::Spree::Refund.prepend(self)
-  end
-end

data/app/models/solidus_stripe/address_from_params_service.rb

@@ -1,72 +0,0 @@
-# frozen_string_literal: true
-
-module SolidusStripe
-  class AddressFromParamsService
-    attr_reader :address_params, :user
-
-    def initialize(address_params, user = nil)
-      @address_params, @user = address_params, user
-    end
-
-    def call
-      if user
-        user.addresses.find_or_initialize_by(attributes)
-      else
-        Spree::Address.new(attributes)
-      end
-    end
-
-    private
-
-    def attributes
-      @attributes ||= begin
-        default_attributes.tap do |attributes|
-          # possibly anonymized attributes:
-          phone = address_params[:phone]
-          lines = address_params[:addressLine]
-          names = address_params[:recipient].split(' ')
-
-          name_attributes = if SolidusSupport.combined_first_and_last_name_in_address? && Spree::Address.column_names.include?("name")
-            {
-              name: address_params[:recipient]
-            }
-          else
-            {
-              firstname: names.first,
-              lastname: names.last,
-            }
-          end
-
-          attributes
-            .merge!(name_attributes)
-            .merge!(
-              state_id: state&.id,
-              phone: phone,
-              address1: lines.first,
-              address2: lines.second
-            )
-            .reject! { |_, value| value.blank? }
-        end
-      end
-    end
-
-    def country
-      @country ||= Spree::Country.find_by_iso(address_params[:country])
-    end
-
-    def state
-      @state ||= begin
-        region = address_params[:region]
-        country.states.find_by(abbr: region) || country.states.find_by(name: region)
-      end
-    end
-
-    def default_attributes
-      {
-        country_id: country.id,
-        city: address_params[:city],
-        zipcode: address_params[:postalCode]
-      }
-    end
-  end
-end

data/app/models/solidus_stripe/create_intents_payment_service.rb

@@ -1,114 +0,0 @@
-# frozen_string_literal: true
-
-module SolidusStripe
-  class CreateIntentsPaymentService
-    attr_reader :intent_id, :stripe, :controller
-
-    delegate :request, :current_order, :params, to: :controller
-
-    def initialize(intent_id, stripe, controller)
-      @intent_id, @stripe, @controller = intent_id, stripe, controller
-    end
-
-    def call
-      invalidate_previous_payment_intents_payments
-      if (payment = create_payment)
-        description = "Solidus Order ID: #{payment.gateway_order_identifier}"
-        stripe.update_intent(nil, intent_id, nil, description: description)
-        true
-      else
-        invalidate_current_payment_intent
-        false
-      end
-    end
-
-    private
-
-    def intent
-      @intent ||= stripe.show_intent(intent_id, {})
-    end
-
-    def invalidate_current_payment_intent
-      stripe.cancel(intent_id)
-    end
-
-    def invalidate_previous_payment_intents_payments
-      if stripe.v3_intents?
-        current_order.payments.pending.where(payment_method: stripe).each(&:void_transaction!)
-      end
-    end
-
-    def create_payment
-      Spree::OrderUpdateAttributes.new(
-        current_order,
-        payment_params,
-        request_env: request.headers.env
-      ).apply
-
-      created_payment = Spree::Payment.find_by(response_code: intent_id)
-      created_payment&.tap { |payment| payment.update!(state: :pending) }
-    end
-
-    def payment_params
-      {
-        payments_attributes: [{
-          payment_method_id: stripe.id,
-          amount: current_order.total,
-          response_code: intent_id,
-          source_attributes: {
-            month: intent_card['exp_month'],
-            year: intent_card['exp_year'],
-            cc_type: intent_card['brand'],
-            last_digits: intent_card['last4'],
-            gateway_payment_profile_id: intent_customer_profile,
-            name: card_holder_name || address_full_name,
-            address_attributes: address_attributes
-          }
-        }]
-      }
-    end
-
-    def intent_card
-      intent_data['payment_method_details']['card']
-    end
-
-    def intent_customer_profile
-      intent.params['payment_method']
-    end
-
-    def card_holder_name
-      (html_payment_source_data['name'] || intent_data['billing_details']['name']).presence
-    end
-
-    def intent_data
-      intent.params['charges']['data'][0]
-    end
-
-    def form_data
-      params[:form_data]
-    end
-
-    def html_payment_source_data
-      if form_data.is_a?(String)
-        data = Rack::Utils.parse_nested_query(form_data)
-        data['payment_source'][stripe.id.to_s]
-      else
-        {}
-      end
-    end
-
-    def address_attributes
-      html_payment_source_data['address_attributes'] || SolidusStripe::AddressFromParamsService.new(form_data).call.attributes
-    end
-
-    def address_full_name
-      bill_address_name = SolidusSupport.combined_first_and_last_name_in_address? ? current_order.bill_address&.name : current_order.bill_address&.full_name
-      bill_address_name || form_data[:recipient]
-    end
-
-    def update_stripe_payment_description
-      description = "Solidus Order ID: #{payment.gateway_order_identifier}"
-      stripe.update_intent(nil, intent_id, nil, description: description)
-    end
-  end
-end

data/app/models/solidus_stripe/prepare_order_for_payment_service.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-module SolidusStripe
-  class PrepareOrderForPaymentService
-    attr_reader :order, :address, :user, :email, :shipping_id
-
-    def initialize(address, controller)
-      @address = address
-      @order = controller.current_order
-      @user = controller.spree_current_user
-      @email = controller.params[:email]
-      @shipping_id = controller.params[:shipping_option][:id]
-    end
-
-    def call
-      set_order_addresses
-      manage_guest_checkout
-      advance_order_to_payment_state
-    end
-
-    private
-
-    def set_shipping_rate
-      order.shipments.each do |shipment|
-        rate = shipment.shipping_rates.find_by(shipping_method: shipping_id)
-        shipment.selected_shipping_rate_id = rate.id
-      end
-    end
-
-    def set_order_addresses
-      order.ship_address = address
-      order.bill_address ||= address
-    end
-
-    def manage_guest_checkout
-      order.email = email unless user
-    end
-
-    def advance_order_to_payment_state
-      while !order.payment?
-        set_shipping_rate if order.state == "delivery"
-        order.next || break
-      end
-    end
-  end
-end

data/app/models/solidus_stripe/shipping_rates_service.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-module SolidusStripe
-  class ShippingRatesService
-    attr_reader :order, :user, :shipping_address_params
-
-    def initialize(order, user, shipping_address_params)
-      @order = order
-      @user = user
-      @shipping_address_params = shipping_address_params
-    end
-
-    def call
-      # setting a temporary and probably incomplete address to the order
-      # only to calculate the available shipping options:
-      order.ship_address = address_from_params
-
-      available_shipping_methods.each_with_object([]) do |(id, rates), options|
-        options << shipping_method_data(id, rates)
-      end
-    end
-
-    private
-
-    def available_shipping_methods
-      shipments = Spree::Stock::SimpleCoordinator.new(order).shipments
-      all_rates = shipments.map(&:shipping_rates).flatten
-
-      all_rates.group_by(&:shipping_method_id).select do |_, rates|
-        rates.size == shipments.size
-      end
-    end
-
-    def shipping_method_data(id, rates)
-      {
-        id: id.to_s,
-        label: Spree::ShippingMethod.find(id).name,
-        amount: (rates.sum(&:cost) * 100).to_i
-      }
-    end
-
-    def address_from_params
-      SolidusStripe::AddressFromParamsService.new(shipping_address_params, user).call
-    end
-  end
-end