solidus_braintree 1.2.0 → 3.0.0

data/app/models/solidus_braintree/source.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require 'solidus_braintree/request_protection'
+
+module SolidusBraintree
+  class Source < ::Spree::PaymentSource
+    include RequestProtection
+
+    PAYPAL = "PayPalAccount"
+    APPLE_PAY = "ApplePayCard"
+    VENMO = "VenmoAccount"
+    CREDIT_CARD = "CreditCard"
+
+    enum paypal_funding_source: {
+      applepay: 0, bancontact: 1, blik: 2, boleto: 3, card: 4, credit: 5, eps: 6, giropay: 7, ideal: 8,
+      itau: 9, maxima: 10, mercadopago: 11, mybank: 12, oxxo: 13, p24: 14, paylater: 15, paypal: 16, payu: 17,
+      sepa: 18, sofort: 19, trustly: 20, venmo: 21, verkkopankki: 22, wechatpay: 23, zimpler: 24
+    }, _suffix: :funding
+
+    belongs_to :user, class_name: ::Spree::UserClassHandle.new, optional: true
+    belongs_to :payment_method, class_name: 'Spree::PaymentMethod'
+    has_many :payments, as: :source, class_name: "Spree::Payment", dependent: :destroy
+
+    belongs_to :customer, class_name: "SolidusBraintree::Customer", optional: true
+
+    validates :payment_type, inclusion: [PAYPAL, APPLE_PAY, VENMO, CREDIT_CARD]
+
+    before_validation :clear_device_data_if_blank
+    before_save :clear_paypal_funding_source, unless: :paypal?
+
+    scope(:with_payment_profile, -> { joins(:customer) })
+    scope(:credit_card, -> { where(payment_type: CREDIT_CARD) })
+
+    delegate :bin, :last_4, :card_type, :expiration_month, :expiration_year, :email,
+      :username, :source_description, to: :braintree_payment_method, allow_nil: true
+
+    # Aliases to match Spree::CreditCard's interface
+    alias_method :last_digits, :last_4
+    alias_method :month, :expiration_month
+    alias_method :year, :expiration_year
+    alias_method :cc_type, :card_type
+
+    # we are not currenctly supporting an "imported" flag
+    def imported
+      false
+    end
+
+    def actions
+      %w[capture void credit]
+    end
+
+    def can_capture?(payment)
+      payment.pending? || payment.checkout?
+    end
+
+    def can_void?(payment)
+      return false unless payment.response_code
+
+      transaction = protected_request do
+        braintree_client.transaction.find(payment.response_code)
+      end
+      Gateway::VOIDABLE_STATUSES.include?(transaction.status)
+    rescue ActiveMerchant::ConnectionError
+      false
+    end
+
+    def can_credit?(payment)
+      payment.completed? && payment.credit_allowed > 0
+    end
+
+    def friendly_payment_type
+      I18n.t(payment_type.underscore, scope: "solidus_braintree.payment_type")
+    end
+
+    def apple_pay?
+      payment_type == APPLE_PAY
+    end
+
+    def paypal?
+      payment_type == PAYPAL
+    end
+
+    def venmo?
+      payment_type == VENMO
+    end
+
+    def reusable?
+      token.present?
+    end
+
+    def credit_card?
+      payment_type == CREDIT_CARD
+    end
+
+    def display_number
+      if paypal?
+        email
+      elsif venmo?
+        username
+      else
+        "XXXX-XXXX-XXXX-#{last_digits.to_s.rjust(4, 'X')}"
+      end
+    end
+
+    def display_paypal_funding_source
+      I18n.t(paypal_funding_source,
+        scope: 'solidus_braintree.paypal_funding_sources',
+        default: paypal_funding_source)
+    end
+
+    def display_payment_type
+      "#{I18n.t('solidus_braintree.payment_type.label')}: #{friendly_payment_type}"
+    end
+
+    private
+
+    def braintree_payment_method
+      return unless braintree_client
+
+      @braintree_payment_method ||= protected_request do
+        braintree_client.payment_method.find(token)
+      end
+    rescue ActiveMerchant::ConnectionError, ArgumentError => e
+      Rails.logger.warn("#{e}: token unknown or missing for #{inspect}")
+      nil
+    end
+
+    def braintree_client
+      @braintree_client ||= payment_method.try(:braintree)
+    end
+
+    def clear_device_data_if_blank
+      self.device_data = nil if device_data.blank?
+    end
+
+    def clear_paypal_funding_source
+      self.paypal_funding_source = nil
+    end
+  end
+end

data/app/models/solidus_braintree/transaction.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'active_model'
+
+module SolidusBraintree
+  class Transaction
+    include ActiveModel::Model
+
+    attr_accessor :nonce, :payment_method, :payment_type, :paypal_funding_source, :address, :email, :phone
+
+    validates :nonce, presence: true
+    validates :payment_method, presence: true
+    validates :payment_type, presence: true
+    validates :email, presence: true
+
+    validate do
+      unless payment_method.is_a? SolidusBraintree::Gateway
+        errors.add(:payment_method, 'Must be braintree')
+      end
+      if address&.invalid?
+        address.errors.each do |error|
+          errors.add(:address, error.full_message)
+        end
+      end
+    end
+
+    def address_attributes=(attributes)
+      self.address = TransactionAddress.new attributes
+    end
+  end
+end

data/app/models/solidus_braintree/transaction_address.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require 'active_model'
+require 'solidus_braintree/country_mapper'
+
+module SolidusBraintree
+  class TransactionAddress
+    include ActiveModel::Model
+    include ActiveModel::Validations::Callbacks
+    include SolidusBraintree::CountryMapper
+
+    attr_accessor :country_code, :name, :city, :zip, :state_code,
+      :address_line_1, :address_line_2, :first_name, :last_name
+
+    validates :address_line_1, :city, :zip, :country_code, presence: true
+    validates :name, presence: true, unless: ->(address){ address.first_name.present? }
+
+    before_validation do
+      self.country_code = country_code.presence || "us"
+    end
+
+    validates :spree_country, presence: true
+    validates :state_code, :spree_state, presence: true, if: :should_match_state_model?
+
+    def initialize(attributes = {})
+      country_name = attributes.delete(:country_name) || ""
+      if attributes[:country_code].blank?
+        attributes[:country_code] = iso_from_name(country_name)
+      end
+
+      super(attributes)
+    end
+
+    def spree_country
+      country_code && (@country ||= ::Spree::Country.find_by(iso: country_code.upcase))
+    end
+
+    def spree_state
+      spree_country && state_code && ( @state ||= spree_country.states.find_by(
+        ::Spree::State.arel_table[:name].matches(state_code).or(
+          ::Spree::State.arel_table[:abbr].matches(state_code)
+        )
+      ))
+    end
+
+    def to_spree_address
+      address = ::Spree::Address.new(
+        city: city,
+        country: spree_country,
+        address1: address_line_1,
+        address2: address_line_2,
+        zipcode: zip
+      )
+
+      if SolidusSupport.combined_first_and_last_name_in_address?
+        address.name = begin
+          if first_name.nil?
+            name
+          else
+            [first_name, last_name].join(" ")
+          end
+        end
+      else
+        ::Spree::Deprecation.warn("first_name and last_name are deprecated. Use name instead.", caller)
+        if first_name.nil?
+          first, last = SolidusBraintree::Address.split_name(name)
+          address.firstname = first
+          address.lastname = last || "(left blank)"
+        else
+          address.firstname = first_name
+          address.lastname = last_name || "(left blank)"
+        end
+      end
+
+      if spree_state
+        address.state = spree_state
+      else
+        address.state_name = state_code
+      end
+      address
+    end
+
+    # Check to see if this address should match to a state model in the database
+    def should_match_state_model?
+      spree_country&.states_required?
+    end
+  end
+end

data/app/models/solidus_braintree/transaction_import.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require 'active_model'
+
+module SolidusBraintree
+  class TransactionImport
+    class InvalidImportError < StandardError; end
+
+    include ActiveModel::Model
+
+    validate do
+      errors.add("Address", "is invalid") if address&.invalid?
+
+      if transaction.invalid?
+        transaction.errors.each do |error|
+          errors.add(error.attribute, error.message)
+        end
+      end
+      errors.none?
+    end
+
+    attr_reader :transaction, :order
+
+    def initialize(order, transaction)
+      @order = order
+      @transaction = transaction
+    end
+
+    def source
+      SolidusBraintree::Source.new(
+        nonce: transaction.nonce,
+        payment_type: transaction.payment_type,
+        payment_method: transaction.payment_method,
+        paypal_funding_source: transaction.paypal_funding_source,
+        user: user
+      )
+    end
+
+    delegate :user, to: :order
+
+    def import!(end_state, restart_checkout: false)
+      if valid?
+        order.email = user&.email || transaction.email
+
+        if address
+          order.shipping_address = order.billing_address = address
+          # work around a bug in most solidus versions
+          # about tax zone cachine between address changes
+          order.instance_variable_set(:@tax_zone, nil)
+        end
+
+        payment = order.payments.new(
+          source: source,
+          payment_method: transaction.payment_method,
+          amount: order.total
+        )
+
+        order.save!
+        order.restart_checkout_flow if restart_checkout
+        advance_order(payment, end_state)
+      else
+        raise InvalidImportError,
+          "Validation failed: #{errors.full_messages.join(', ')}"
+      end
+    end
+
+    def address
+      transaction.address && transaction.address.to_spree_address.tap do |address|
+        address.phone = transaction.phone
+      end
+    end
+
+    def state_before_current?(state)
+      steps = order.checkout_steps
+      steps.index(state) < (steps.index(order.state) || 0)
+    end
+
+    protected
+
+    def advance_order(payment, end_state)
+      return if state_before_current?(end_state)
+
+      until order.state == end_state
+        order.next!
+        update_payment_total(payment) if order.payment?
+      end
+    end
+
+    def update_payment_total(payment)
+      payment_total = order.payments.where(state: %w[checkout pending]).sum(:amount)
+      payment_difference = order.outstanding_balance - payment_total
+
+      return unless payment_difference != 0
+
+      payment.update!(amount: payment.amount + payment_difference)
+    end
+  end
+end

data/app/views/spree/api/payments/source_views/_braintree.json.jbuilder

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+json.call(payment_source, :id, :token, :created_at)

data/bin/console

@@ -1,14 +1,17 @@
 #!/usr/bin/env ruby
 
+# frozen_string_literal: true
+
 require "bundler/setup"
 require "solidus_braintree"
 
 # You can add fixtures and/or initialization code here to make experimenting
 # with your gem easier. You can also use a different console, if you like.
+$LOAD_PATH.unshift(*Dir["#{__dir__}/../app/*"])
 
 # (If you use this, don't forget to add pry to your Gemfile!)
 # require "pry"
 # Pry.start
 
 require "irb"
-IRB.start
+IRB.start(__FILE__)

data/bin/dummy-app

@@ -0,0 +1,37 @@
+#!/usr/bin/env bash
+
+set -e
+
+extension_name="solidus_braintree"
+
+# Stay away from the bundler env of the containing extension.
+function unbundled {
+  ruby -rbundler -e'b = proc {system *ARGV}; Bundler.respond_to?(:with_unbundled_env) ? Bundler.with_unbundled_env(&b) : Bundler.with_clean_env(&b)' -- "$@"
+}
+
+# "sqlite" is set by the ORB extension instead of "sqlite3",
+# all other options are already in the format expected by `rails new`.
+test "$DB" = "sqlite" && export DB="sqlite3"
+
+rm -rf ./dummy-app
+rails new dummy-app \
+  --database=${DB:-sqlite3} \
+  --skip-git \
+  --skip-keeps \
+  --skip-rc \
+  --skip-bootsnap \
+  --skip-test
+
+if [ ! -d "dummy-app" ]; then
+  echo 'dummy-app rails application failed'
+  exit 1
+fi
+
+cd ./dummy-app
+unbundled bundle add solidus --github solidusio/solidus --branch "${BRANCH:-master}" --version '> 0.a'
+unbundled bundle exec rake db:drop db:create
+unbundled bundle exec rails generate solidus:install --auto-accept --payment-method=none --no-seed --no-sample "$@"
+unbundled bundle add $extension_name --path ..
+unbundled bundle exec rails generate $extension_name:install --migrate --specs=all
+
+

data/bin/rails

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 
-ENGINE_ROOT = File.expand_path('../..', __FILE__)
-ENGINE_PATH = File.expand_path('../../lib/solidus_braintree/engine', __FILE__)
-
-require 'rails/all'
-require 'rails/engine/commands'
+if %w[g generate].include? ARGV.first
+  exec "#{__dir__}/rails-engine", *ARGV
+else
+  exec "#{__dir__}/rails-sandbox", *ARGV
+end

data/bin/rails-dummy-app

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+
+root = "#{__dir__}/.."
+app_root = "#{root}/dummy-app"
+
+unless File.exist? "#{app_root}/bin/rails"
+  warn 'Creating the dummy-app app...'
+  Dir.chdir root do
+    system "#{root}/bin/dummy-app" or begin
+      warn 'Automatic creation of the dummy-app app failed'
+      exit 1
+    end
+  end
+end
+
+Dir.chdir app_root
+exec "#{app_root}/bin/rails", *ARGV

data/bin/rails-engine

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+# This command will automatically be run when you run "rails" with Rails gems
+# installed from the root of your application.
+
+ENGINE_ROOT = File.expand_path('..', __dir__)
+ENGINE_PATH = File.expand_path('../lib/solidus_braintree/engine', __dir__)
+
+# Set up gems listed in the Gemfile.
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../Gemfile', __dir__)
+require 'bundler/setup' if File.exist?(ENV['BUNDLE_GEMFILE'])
+
+require 'rails/all'
+require 'rails/engine/commands'

data/bin/rails-sandbox

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+
+app_root = 'sandbox'
+
+unless File.exist? "#{app_root}/bin/rails"
+  warn 'Creating the sandbox app...'
+  Dir.chdir "#{__dir__}/.." do
+    system "#{__dir__}/sandbox" or begin
+      warn 'Automatic creation of the sandbox app failed'
+      exit 1
+    end
+  end
+end
+
+Dir.chdir app_root
+exec 'bin/rails', *ARGV

data/bin/rake

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("rake", "rake")

data/bin/rspec

@@ -0,0 +1,11 @@
+#!/usr/bin/env bash
+
+set -e
+
+bin/rails-dummy-app generate solidus_braintree:install --force --migrate --specs=all
+
+cd dummy-app/
+rspec "$@"
+exit_status=$?
+cd -
+exit $exit_status

data/bin/sandbox

@@ -0,0 +1,61 @@
+#!/usr/bin/env bash
+
+set -e
+
+case "$DB" in
+postgres|postgresql)
+  RAILSDB="postgresql"
+  ;;
+mysql)
+  RAILSDB="mysql"
+  ;;
+sqlite|'')
+  RAILSDB="sqlite3"
+  ;;
+*)
+  echo "Invalid DB specified: $DB"
+  exit 1
+  ;;
+esac
+
+if [ ! -z $SOLIDUS_BRANCH ]
+then
+  BRANCH=$SOLIDUS_BRANCH
+else
+  BRANCH="master"
+fi
+
+extension_name="solidus_braintree"
+
+# Stay away from the bundler env of the containing extension.
+function unbundled {
+  ruby -rbundler -e'b = proc {system *ARGV}; Bundler.respond_to?(:with_unbundled_env) ? Bundler.with_unbundled_env(&b) : Bundler.with_clean_env(&b)' -- "$@"
+}
+
+rm -rf ./sandbox
+rails new sandbox \
+  --database="$RAILSDB" \
+  --skip-git \
+  --skip-keeps \
+  --skip-rc \
+  --skip-bootsnap \
+  --skip-test
+
+if [ ! -d "sandbox" ]; then
+  echo 'sandbox rails application failed'
+  exit 1
+fi
+
+cd ./sandbox
+unbundled bundle add solidus --github solidusio/solidus --branch "${BRANCH:-master}" --version '> 0.a'
+unbundled bundle exec rake db:drop db:create
+unbundled bundle exec rails generate solidus:install --payment-method=none --auto-accept "$@"
+unbundled bundle add ${extension_name} --path '../'
+unbundled bundle exec rails generate ${extension_name}:install --frontend=starter --migrate=true
+
+echo
+echo "🚀 Sandbox app successfully created for ${extension_name}!"
+echo "🚀 Using $RAILSDB and Solidus $BRANCH"
+echo "🚀 Use 'export DB=[postgres|mysql|sqlite]' to control the DB adapter"
+echo "🚀 Use 'export SOLIDUS_BRANCH=<BRANCH-NAME>' to control the Solidus version"
+echo "🚀 This app is intended for test purposes."

data/bin/setup

@@ -1,7 +1,8 @@
-#!/bin/bash
+#!/usr/bin/env bash
 set -euo pipefail
 IFS=$'\n\t'
+set -vx
 
-bundle install
-
-# Do any other automated setup that you need to do here
+gem install bundler --conservative
+bundle update
+bin/rake clobber

data/config/locales/en.yml

@@ -1,4 +1,96 @@
 en:
+  activerecord:
+    models:
+      solidus_braintree/gateway: Braintree
+    attributes:
+      solidus_braintree/configuration:
+        paypal: PayPal
+        apple_pay: Apple Pay
+        credit_card: Credit Card
+        three_d_secure: 3D Secure
+        venmo: Venmo
+  spree:
+    admin:
+      tab:
+        braintree: Braintree
+    client_sdk_enabled: Client SDK enabled?
+    environment: Environment
+    merchant_currency_map: Merchant currency map
+    merchant_id: Merchant ID
+    paypal_payee_email_map: Paypal payee email map
+    private_key: Private key
+    public_key: Public key
+    token_generation_enabled: Token generation enabled?
+    paypal_flow: PayPal flow
+    paypal_funding: 'PayPal Funding: %{funding}'
+    paypal_funding_source: 'PayPal Funding Source'
   solidus_braintree:
-    paypal_header_html: <h5>Checkout with</h5>
-    creditcard_header_html: <p class="or">or</p><h5>Enter a credit card:</h5>
+    braintree: Braintree
+    nonce: Nonce
+    token: Token
+    errors:
+      default_error: "Something bad happened!"
+      paypal_popup_closed: "PayPal popup has been closed before payment completion."
+      empty_fields: "All fields are empty! Please fill out the form."
+      invalid_fields: "Some payment input fields are invalid."
+      invalid_card: "Credit card data is incorrect."
+      network_error: "Network error occurred."
+      duplicate_iframe: "Duplicate Braintree iframe."
+      fail_on_duplicate: "This payment method already exists in your vault."
+      cvv_verification_failed: "CVV did not pass verification."
+      threeds:
+        authentication_failed: "3D Secure authentication failed. Please try again using a different payment method."
+      venmo:
+        canceled: "App is not available or you aborted the payment flow."
+        desktop_canceled: "Venmo authorization was canceled by closing the Venmo Desktop modal."
+        app_canceled: "Payment flow was canceled."
+    payment_type:
+      label: Payment Type
+      apple_pay_card: Apple Pay
+      credit_card: Credit Card
+      pay_pal_account: PayPal
+      venmo_account: Venmo
+    configurations:
+      title: Braintree Configurations
+      tab: Braintree
+      update_success: Successfully updated Braintree configurations.
+      update_error: An error occurred while updating Braintree configurations.
+    gateway_rejection_reasons:
+      avs: AVS check failed.
+      avs_and_cvv: AVS and CVV check failed.
+      cvv: CVV check failed.
+      duplicate: Duplicate transaction.
+      fraud: Credit card was rejected because of potential fraud.
+      three_d_secure: 3D Secure check failed.
+    transaction_statuses:
+      authorization_expired: Payment authorization has expired.
+      failed: An error occurred when sending the transaction to the processor.
+      gateway_rejected: Gateway rejected this transaction.
+      processor_declined: Processor declined this transaction.
+      settlement_declined: Settlement was declined by processor.
+    paypal_funding_sources:
+       applepay: 'Apple Pay'
+       bancontact: 'Bancontact'
+       blik: 'BLIK'
+       boleto: 'Boleto'
+       card: 'Credit or debit card'
+       credit: 'PayPal Credit'
+       eps: 'eps'
+       giropay: 'giropay'
+       ideal: 'iDEAL'
+       itau: 'Itau'
+       maxima: 'Maxima'
+       mercadopago: 'Mercado Pago'
+       mybank: 'MyBank'
+       oxxo: 'Oxxo'
+       p24: 'Przelewy24'
+       paylater: 'Pay Later'
+       paypal: 'PayPal'
+       payu: 'PayU'
+       sepa: 'SEPA-Lastschrift'
+       sofort: 'Sofort'
+       trustly: 'Trustly'
+       venmo: 'Venmo'
+       verkkopankki: 'Verkkopankki'
+       wechatpay: 'WeChat Pay'
+       zimpler: 'Zimpler'