archetype_spree_gateway 3.9.5

data/app/models/spree/gateway/stripe_ach_gateway.rb

@@ -0,0 +1,60 @@
+module Spree
+  class Gateway::StripeAchGateway < Gateway::StripeGateway
+
+    def method_type
+      'stripe_ach'
+    end
+
+    def payment_source_class
+      Check
+    end
+
+    def verify(source, gateway_options)
+      provider.verify(source, gateway_options)
+    end
+
+    def create_profile(payment)
+      return unless payment.source&.gateway_customer_profile_id.nil?
+
+      options = {
+        email: payment.order.user&.email || payment.order.email,
+        login: preferred_secret_key,
+      }.merge! address_for(payment)
+
+      source = payment.source
+      bank_account = if source.gateway_payment_profile_id.present?
+                       source.gateway_payment_profile_id
+                     else
+                       source
+                     end
+
+      response = provider.store(bank_account, options)
+
+      if response.success?
+        payment.source.update!({
+                                 gateway_customer_profile_id: response.params['id'],
+                                 gateway_payment_profile_id: response.params['default_source'] || response.params['default_card']
+                               })
+
+      else
+        payment.send(:gateway_error, response.message)
+      end
+    end
+
+    def supports?(_source)
+      true
+    end
+
+    def available_for_order?(order)
+      # Stripe ACH payments are supported only for US customers
+      # Therefore we need to check order's addresses
+      return unless order.ship_address_id && order.bill_address_id
+      return unless order.ship_address && order.bill_address_id
+
+      usa_id = ::Spree::Country.find_by(iso: 'US')&.id
+      return false unless usa_id
+
+      order.ship_address.country_id == usa_id && order.bill_address.country_id == usa_id
+    end
+  end
+end

data/app/models/spree/gateway/stripe_apple_pay_gateway.rb

@@ -0,0 +1,10 @@
+module Spree
+  class Gateway::StripeApplePayGateway < Gateway::StripeGateway
+    preference :country_code, :string, default: 'US'
+    preference :domain_verification_certificate, :text
+
+    def method_type
+      'stripe_apple_pay'
+    end
+  end
+end

data/app/models/spree/gateway/stripe_elements_gateway.rb

@@ -0,0 +1,61 @@
+module Spree
+  class Gateway::StripeElementsGateway < Gateway::StripeGateway
+    preference :intents, :boolean, default: true
+
+    def method_type
+      'stripe_elements'
+    end
+
+    def provider_class
+      if get_preference(:intents)
+        ActiveMerchant::Billing::StripePaymentIntentsGateway
+      else
+        ActiveMerchant::Billing::StripeGateway
+      end
+    end
+
+    def create_profile(payment)
+      return unless payment.source.gateway_customer_profile_id.nil?
+
+      options = {
+        email: payment.order.email,
+        login: preferred_secret_key
+      }.merge! address_for(payment)
+
+      source = update_source!(payment.source)
+      creditcard = source.gateway_payment_profile_id.present? ? source.gateway_payment_profile_id : source
+      response = provider.store(creditcard, options)
+      if response.success?
+        if get_preference(:intents)
+          payment.source.update!(
+            cc_type: payment.source.cc_type,
+            gateway_customer_profile_id: response.params['id'],
+            gateway_payment_profile_id: response.params['sources']['data'].first['id']
+          )
+        else
+          response_cc_type = response.params['sources']['data'].first['brand']
+          cc_type = CARD_TYPE_MAPPING.include?(response_cc_type) ? CARD_TYPE_MAPPING[response_cc_type] : payment.source.cc_type
+          payment.source.update!({
+            cc_type: cc_type, # side-effect of update_source!
+            gateway_customer_profile_id: response.params['id'],
+            gateway_payment_profile_id: response.params['default_source'] || response.params['default_card']
+          })
+        end
+      else
+        payment.send(:gateway_error, response.message)
+      end
+    end
+
+    private
+
+    def options_for_purchase_or_auth(money, creditcard, gateway_options)
+      money, creditcard, options = super
+      options[:execute_threed] = get_preference(:intents)
+      return money, creditcard, options
+    end
+
+    def public_preference_keys
+      %i[publishable_key test_mode intents]
+    end
+  end
+end

data/app/models/spree/gateway/stripe_gateway.rb

@@ -0,0 +1,151 @@
+module Spree
+  class Gateway::StripeGateway < Gateway
+    preference :secret_key, :string
+    preference :publishable_key, :string
+
+    CARD_TYPE_MAPPING = {
+      'American Express' => 'american_express',
+      'Diners Club' => 'diners_club',
+      'Discover' => 'discover',
+      'JCB' => 'jcb',
+      'Laser' => 'laser',
+      'Maestro' => 'maestro',
+      'MasterCard' => 'master',
+      'Solo' => 'solo',
+      'Switch' => 'switch',
+      'Visa' => 'visa'
+    }
+
+    def method_type
+      'stripe'
+    end
+
+    def provider_class
+      ActiveMerchant::Billing::StripeGateway
+    end
+
+    def payment_profiles_supported?
+      true
+    end
+
+    def purchase(money, creditcard, gateway_options)
+      provider.purchase(*options_for_purchase_or_auth(money, creditcard, gateway_options))
+    end
+
+    def authorize(money, creditcard, gateway_options)
+      provider.authorize(*options_for_purchase_or_auth(money, creditcard, gateway_options))
+    end
+
+    def capture(money, response_code, gateway_options)
+      provider.capture(money, response_code, gateway_options)
+    end
+
+    def credit(money, creditcard, response_code, gateway_options)
+      provider.refund(money, response_code, {})
+    end
+
+    def void(response_code, creditcard, gateway_options)
+      provider.void(response_code, {})
+    end
+
+    def cancel(response_code)
+      provider.void(response_code, {})
+    end
+
+    def create_profile(payment)
+      return unless payment.source.gateway_customer_profile_id.nil?
+
+      options = {
+        email: payment.order.email,
+        login: preferred_secret_key,
+      }.merge! address_for(payment)
+
+      source = update_source!(payment.source)
+      if source.gateway_payment_profile_id.present?
+        creditcard = source.gateway_payment_profile_id
+      else
+        creditcard = source
+      end
+
+      response = provider.store(creditcard, options)
+      if response.success?
+        cc_type=payment.source.cc_type
+        response_cc_type = response.params['sources']['data'].first['brand']
+        cc_type = CARD_TYPE_MAPPING[response_cc_type] if CARD_TYPE_MAPPING.include?(response_cc_type)
+
+        payment.source.update!({
+          cc_type: cc_type, # side-effect of update_source!
+          gateway_customer_profile_id: response.params['id'],
+          gateway_payment_profile_id: response.params['default_source'] || response.params['default_card']
+        })
+
+      else
+        payment.send(:gateway_error, response.message)
+      end
+    end
+
+    private
+
+    # In this gateway, what we call 'secret_key' is the 'login'
+    def options
+      super.merge(
+        login: preferred_secret_key,
+        application: app_info
+      )
+    end
+
+    def options_for_purchase_or_auth(money, creditcard, gateway_options)
+      options = {}
+      options[:description] = "Spree Order ID: #{gateway_options[:order_id]}"
+      options[:currency] = gateway_options[:currency]
+      options[:application] = app_info
+
+      if customer = creditcard.gateway_customer_profile_id
+        options[:customer] = customer
+      end
+      if token_or_card_id = creditcard.gateway_payment_profile_id
+        # The Stripe ActiveMerchant gateway supports passing the token directly as the creditcard parameter
+        # The Stripe ActiveMerchant gateway supports passing the customer_id and credit_card id
+        # https://github.com/Shopify/active_merchant/issues/770
+        creditcard = token_or_card_id
+      end
+      return money, creditcard, options
+    end
+
+    def address_for(payment)
+      {}.tap do |options|
+        if address = payment.order.bill_address
+          options.merge!(address: {
+            address1: address.address1,
+            address2: address.address2,
+            city: address.city,
+            zip: address.zipcode
+          })
+
+          if country = address.country
+            options[:address].merge!(country: country.name)
+          end
+
+          if state = address.state
+            options[:address].merge!(state: state.name)
+          end
+        end
+      end
+    end
+
+    def update_source!(source)
+      source.cc_type = CARD_TYPE_MAPPING[source.cc_type] if CARD_TYPE_MAPPING.include?(source.cc_type)
+      source
+    end
+
+    def app_info
+      name_with_version = "SpreeGateway/#{SpreeGateway.version}"
+      url = 'https://spreecommerce.org'
+      "#{name_with_version} #{url}"
+    end
+
+    def public_preference_keys
+      %i[publishable_key test_mode]
+    end
+  end
+end

data/app/models/spree/gateway/usa_epay_transaction.rb

@@ -0,0 +1,9 @@
+module Spree
+  class Gateway::UsaEpayTransaction < Gateway
+    preference :login, :string
+
+    def provider_class
+      ActiveMerchant::Billing::UsaEpayTransactionGateway
+    end
+  end
+end

data/app/models/spree/gateway/worldpay.rb

@@ -0,0 +1,91 @@
+module Spree
+  class Gateway::Worldpay < Gateway
+    preference :login, :string
+    preference :password, :string
+    preference :currency, :string, :default => 'GBP'
+    preference :installation_id, :string
+
+    preference :american_express_login, :string
+    preference :discover_login, :string
+    preference :jcb_login, :string
+    preference :mastercard_login, :string
+    preference :maestro_login, :string
+    preference :visa_login, :string
+
+    def provider_class
+      ActiveMerchant::Billing::WorldpayGateway
+    end
+
+    def purchase(money, credit_card, options = {})
+      provider = credit_card_provider(credit_card, options)
+      provider.purchase(money, credit_card, options)
+    end
+
+    def authorize(money, credit_card, options = {})
+      provider = credit_card_provider(credit_card, options)
+      provider.authorize(money, credit_card, options)
+    end
+
+    def capture(money, authorization, options = {})
+      provider = credit_card_provider(auth_credit_card(authorization), options)
+      provider.capture(money, authorization, options)
+    end
+
+    def refund(money, authorization, options = {})
+      provider = credit_card_provider(auth_credit_card(authorization), options)
+      provider.refund(money, authorization, options)
+    end
+
+    def credit(money, authorization, options = {})
+      refund(money, authorization, options)
+    end
+
+    def void(authorization, options = {})
+      provider = credit_card_provider(auth_credit_card(authorization), options)
+      provider.void(authorization, options)
+    end
+
+    private
+
+    def options_for_card(credit_card, options)
+      options[:login] = login_for_card(credit_card)
+      options = options().merge( options )
+    end
+
+    def auth_credit_card(authorization)
+      Spree::Payment.find_by_response_code(authorization).source
+    end
+
+    def credit_card_provider(credit_card, options = {})
+      gateway_options = options_for_card(credit_card, options)
+      gateway_options.delete :login if gateway_options.has_key?(:login) and gateway_options[:login].nil?
+      gateway_options[:currency] = self.preferred_currency
+      gateway_options[:inst_id] = self.preferred_installation_id
+      ActiveMerchant::Billing::Base.gateway_mode = gateway_options[:server].to_sym
+      @provider = provider_class.new(gateway_options)
+    end
+
+    def login_for_card(card)
+      case card.brand
+        when 'american_express'
+          choose_login preferred_american_express_login
+        when 'discover'
+          choose_login preferred_discover_login
+        when 'jcb'
+          choose_login preferred_jcb_login
+        when 'maestro'
+          choose_login preferred_maestro_login
+        when 'master'
+          choose_login preferred_mastercard_login
+        when 'visa'
+          choose_login preferred_visa_login
+        else
+          preferred_login
+      end
+    end
+
+    def choose_login(login)
+      return login ? login : preferred_login
+    end
+  end
+end

data/app/models/spree/payu_polska.rb

@@ -0,0 +1,41 @@
+module Spree
+  class PayuPolska < Spree::Base
+
+    attr_accessor :imported
+
+    belongs_to :payment_method
+    belongs_to :user, class_name: Spree.user_class.to_s, foreign_key: 'user_id',
+               optional: true
+    has_many :payments, as: :source
+
+    scope :with_payment_profile, -> { where.not(gateway_customer_profile_id: nil) }
+
+    validates :account_holder_name, presence: true
+    validates :account_holder_type, presence: true, inclusion: { in: %w[Individual Company] }
+    validates :account_number, presence: true, numericality: { only_integer: true }
+    validates :routing_number, presence: true, numericality: { only_integer: true }
+
+    def has_payment_profile?
+      gateway_customer_profile_id.present? || gateway_payment_profile_id.present?
+    end
+
+    def actions
+      %w[capture void credit]
+    end
+
+    def can_capture?(payment)
+      payment.pending? || payment.checkout?
+    end
+
+    # Indicates whether its possible to void the payment.
+    def can_void?(payment)
+      !payment.failed? && !payment.void?
+    end
+
+    # Indicates whether its possible to credit the payment.  Note that most gateways require that the
+    # payment be settled first which generally happens within 12-24 hours of the transaction.
+    def can_credit?(payment)
+      payment.completed? && payment.credit_allowed > 0
+    end
+  end
+end

data/app/models/spree_gateway/apple_pay_order_decorator.rb

@@ -0,0 +1,20 @@
+module SpreeGateway
+  module ApplePayOrderDecorator
+    def confirmation_required?
+      return false if paid_with_apple_pay?
+
+      # Little hacky fix for #4117
+      # If this wasn't here, order would transition to address state on confirm failure
+      # because there would be no valid payments any more.
+      Spree::Config[:always_include_confirm_step] ||
+        payments.valid.map(&:payment_method).compact.any?(&:payment_profiles_supported?) ||
+        confirm?
+    end
+
+    def paid_with_apple_pay?
+      payments.valid.any?(&:apple_pay?)
+    end
+  end
+end
+
+::Spree::Order.prepend(::SpreeGateway::ApplePayOrderDecorator)

data/app/models/spree_gateway/apple_pay_payment_decorator.rb

@@ -0,0 +1,9 @@
+module SpreeGateway
+  module ApplePayPaymentDecorator
+    def apple_pay?
+      payment_method.is_a? Spree::Gateway::StripeApplePayGateway
+    end
+  end
+end
+
+::Spree::Payment.prepend(::SpreeGateway::ApplePayPaymentDecorator)

data/app/models/spree_gateway/credit_card_decorator.rb

@@ -0,0 +1,10 @@
+module SpreeGateway
+  module CreditCardDecorator
+    def set_last_digits
+      self.last_digits ||= number.to_s.length <= 4 ? number : number.to_s.slice(-4..-1)
+    end
+
+  end
+end
+
+::Spree::CreditCard.prepend(::SpreeGateway::CreditCardDecorator)

data/app/models/spree_gateway/order_decorator.rb

@@ -0,0 +1,28 @@
+module SpreeGateway
+  module OrderDecorator
+    def self.prepended(base)
+      return if base.checkout_steps.key?(:payment_confirm)
+
+      base.insert_checkout_step(
+        :payment_confirm,
+        before: :complete,
+        if: ->(order) { order.intents? }
+      )
+    end
+
+    def process_payments!
+      # Payments are processed in confirm_payment step where after successful
+      # 3D Secure authentication `intent_client_key` is saved for payment.
+      # In case authentication is unsuccessful, `intent_client_key` is removed.
+      return if intents? && payments.valid.last.intent_client_key.present?
+
+      super
+    end
+
+    def intents?
+      payments.valid.map { |p| p.payment_method&.has_preference?(:intents) && p.payment_method&.get_preference(:intents) }.any?
+    end
+  end
+end
+
+::Spree::Order.prepend(::SpreeGateway::OrderDecorator)

data/app/models/spree_gateway/payment_decorator.rb

@@ -0,0 +1,36 @@
+module SpreeGateway
+  module PaymentDecorator
+    def handle_response(response, success_state, failure_state)
+      if response.success? && response.respond_to?(:params)
+        self.intent_client_key = response.params['client_secret'] if response.params['client_secret']
+      end
+      super
+    end
+
+    def verify!(**options)
+      process_verification(options)
+    end
+
+    private
+
+    def process_verification(**options)
+      protect_from_connection_error do
+        response = payment_method.verify(source, options)
+
+        record_response(response)
+
+        if response.success?
+          unless response.authorization.nil?
+            self.response_code = response.authorization
+
+            source.update(status: response.params['status'])
+          end
+        else
+          gateway_error(response)
+        end
+      end
+    end
+  end
+end
+
+::Spree::Payment.prepend(::SpreeGateway::PaymentDecorator)

data/app/views/spree/checkout/_payment_confirm.html.erb

@@ -0,0 +1,39 @@
+<div id='errorBox' class='errorExplanation alert alert-danger' style='display:none'></div>
+<div id='successBox' class='alert alert-success' style='display:none'></div>
+<div id='infoBox' class='alert alert-info'><%= t('spree.please_wait_for_confirmation_popup') %></div>
+
+<% if @client_secret.present? && @pk_key.present? %>
+  <script type="text/javascript" src="https://js.stripe.com/v3/"></script>
+  <script>
+    var form = document.getElementById('checkout_form_payment_confirm');
+
+    function confirmCardPaymentResponseHandler(response) {
+      $.post("/api/v2/storefront/intents/handle_response", { response: response, order_token: "<%= @order.token %>" }).done(function (result) {
+          // conditional needs for spree 3.7
+          if(form.elements["commit"]) {
+              form.elements["commit"].disabled = false;
+          }
+        $('#successBox').html(result.message);
+        $('#successBox').show();
+        form.submit();
+      }).fail(function(result) {
+          if(form.elements["commit"]) {
+              form.elements["commit"].disabled = false;
+          }
+        $('#errorBox').html(result.responseJSON.error);
+        $('#errorBox').show();
+      });
+    }
+
+    var stripeElements = Stripe("<%= @pk_key %>");
+    stripeElements.confirmCardPayment("<%= @client_secret %>").then(function(result) {
+      $('#infoBox').hide();
+      confirmCardPaymentResponseHandler(result);
+    });
+
+    document.addEventListener('DOMContentLoaded', function(){
+      form.elements["commit"].value = "continue"
+      form.elements["commit"].disabled = true
+    });
+  </script>
+<% end %>

data/app/views/spree/checkout/_payu.html

@@ -0,0 +1,12 @@
+<div class="text-center">
+  <img width="150px" src="https://poland.payu.com/wp-content/uploads/sites/14/2020/05/PAYU_LOGO_LIME-990x640.png" />
+  <br/>
+</div>
+
+
+<script type="text/javascript">
+  button = document.getElementsByClassName("checkout-content-save-continue-button")[0]
+  button.addEventListener("click", (e) => {
+    e.preventDefault();
+  });
+</script>

data/config/initializers/inflections.rb

@@ -0,0 +1,3 @@
+ActiveSupport::Inflector.inflections(:en) do |inflect|
+  inflect.acronym 'AU'
+end

data/config/initializers/spree_permitted_attributes.rb

@@ -0,0 +1,5 @@
+module Spree
+  module PermittedAttributes
+    @@source_attributes += %i[account_number routing_number account_holder_type account_holder_name status]
+  end
+end

data/config/locales/bg.yml

@@ -0,0 +1,4 @@
+---
+bg:
+  spree:
+    payment_has_been_cancelled: Плащането беше прекъснато.

data/config/locales/de.yml

@@ -0,0 +1,4 @@
+---
+de:
+  spree:
+    payment_has_been_cancelled: Die Zahlung wurde abgebrochen.

data/config/locales/en.yml

@@ -0,0 +1,47 @@
+---
+en:
+  activerecord:
+    attributes:
+      spree/check:
+        account_holder_name: Account Holder Name
+        account_holder_type: Account Holder Type
+        account_number: Account Number
+        routing_number: Routing Number
+  spree:
+    check: Check
+    payment_has_been_cancelled: The payment has been cancelled.
+    please_wait_for_confirmation_popup: Please wait for payment confirmation popup to appear.
+    payment_successfully_authorized: The payment was successfully authorized.
+    no_payment_authorization_needed: Payment autorization not needed.
+    order_state:
+      payment_confirm: Verify payment
+    log_entry:
+      braintree:
+        message: Message
+        status: Status
+        cc_token: Braintree Credit Card Token
+        customer_id: Braintree Customer ID
+        cvv_result: CVV Result
+        avs_result_title: AVS result
+        avs_result:
+          message: Message
+          street_match: Street Match
+          postal_match: Postal Match
+      stripe:
+        message: Message
+        charge_id: Stripe Charge ID
+        card_id: Stripe Card ID
+        cvv_result: CVV Result
+        cvc_check: CVC Check
+        address_zip_check: Address ZIP check
+    stripe:
+      ach:
+        account_holder_name: Account Holder Name
+        account_holder_type: Account Holder Type
+        routing_number: Routing Number
+        account_number: Account Number
+        verify_account_number: Verify Account Number
+        verify_bank_account: Verify Bank Account
+        first_deposit: First Deposit
+        second_deposit: Second Deposit
+    bank_transfer: bank_transfer

data/config/locales/sv.yml

@@ -0,0 +1,4 @@
+---
+sv:
+  spree:
+    payment_has_been_cancelled: Betalningen har avbrutits.