solidus_paypal_braintree 0.4.0 → 1.1.1

data/app/assets/javascripts/solidus_paypal_braintree/venmo_button.js

@@ -0,0 +1,86 @@
+//= require solidus_paypal_braintree/constants
+/**
+ * Constructor for Venmo button object
+ * @constructor
+ * @param {object} element - The DOM element of your Venmo button
+ */
+SolidusPaypalBraintree.VenmoButton = function(element, venmoOptions) {
+  this._element = element;
+  this._client = null;
+  this._venmoOptions = venmoOptions || {};
+
+  if(!this._element) {
+    throw new Error("Element for the Venmo button must be present on the page");
+  }
+};
+
+/**
+ * Creates the Venmo session using the provided options and enables the button
+ *
+ * @param {object} options - The options passed to tokenize when constructing
+ *                           the Venmo instance
+ *
+ * See {@link https://braintree.github.io/braintree-web/3.84.0/module-braintree-web_venmo.html#.create}
+ */
+SolidusPaypalBraintree.VenmoButton.prototype.initialize = function() {
+  this._client = new SolidusPaypalBraintree.createClient({
+    useVenmo: true,
+    newBrowserTabSupported: this._venmoOptions.newBrowserTabSupported,
+    flow: this._venmoOptions.flow
+  });
+
+  return this._client.initialize().then(this.initializeCallback.bind(this));
+};
+
+SolidusPaypalBraintree.VenmoButton.prototype.initializeCallback = function() {
+  this._venmoInstance = this._client.getVenmoInstance();
+
+  this._element.classList.add('visible');
+
+  // Check if tokenization results already exist. This occurs when your
+  // checkout page is relaunched in a new tab.
+  if (!this._venmoOptions.newBrowserTabSupported && this._venmoInstance.hasTokenizationResult()) {
+    this.tokenize();
+  }
+
+  this._element.addEventListener('click', function(event) {
+    event.preventDefault();
+    this._element.disabled = true;
+    this.initializeVenmoSession();
+  }.bind(this), false);
+};
+
+SolidusPaypalBraintree.VenmoButton.prototype.initializeVenmoSession = function() {
+  this.tokenize();
+};
+
+SolidusPaypalBraintree.VenmoButton.prototype.tokenize = function() {
+  var venmoButton = this._element;
+  this._venmoInstance.tokenize().then(handleVenmoSuccess).catch(handleVenmoError).then(function () {
+    venmoButton.removeAttribute('disabled');
+  });
+};
+
+function handleVenmoSuccess(payload) {
+  var $paymentForm = $("#checkout_form_payment");
+  var $nonceField = $("#venmo_payment_method_nonce", $paymentForm);
+
+  // Disable hostedFields' and enable Venmo's inputs as they use the same fields.
+  // Otherwise, they will clash. (Disabled inputs are not used on form submission)
+  $('.hosted-fields input').each(function(_index, input) {
+    input.disabled = true;
+  });
+  $('.venmo-fields input').each(function(_index, input) {
+    input.removeAttribute('disabled');
+  });
+
+  // remove hostedFields submit listener, otherwise empty credit card errors occur
+  $paymentForm.off('submit');
+
+  $nonceField.val(payload.nonce);
+  $paymentForm.submit();
+}
+
+function handleVenmoError(error) {
+  SolidusPaypalBraintree.config.braintreeErrorHandle(error);
+}

data/app/assets/javascripts/spree/backend/solidus_paypal_braintree.js

@@ -68,8 +68,8 @@ $(function() {
   if (!$paymentForm.length || !$hostedFields.length) { return; }
 
   $.when(
-    $.getScript("https://js.braintreegateway.com/web/3.34.0/js/client.min.js"),
-    $.getScript("https://js.braintreegateway.com/web/3.34.0/js/hosted-fields.min.js")
+    $.getScript("https://js.braintreegateway.com/web/3.84.0/js/client.min.js"),
+    $.getScript("https://js.braintreegateway.com/web/3.84.0/js/hosted-fields.min.js")
   ).done(function() {
     $hostedFields.each(function() {
       var $this = $(this),

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

@@ -4,9 +4,9 @@
 $(document).ready(function() {
   if (document.getElementById("empty-cart")) {
     $.when(
-      $.getScript("https://js.braintreegateway.com/web/3.31.0/js/client.min.js"),
-      $.getScript("https://js.braintreegateway.com/web/3.31.0/js/paypal-checkout.min.js"),
-      $.getScript("https://js.braintreegateway.com/web/3.31.0/js/data-collector.min.js")
+      $.getScript("https://js.braintreegateway.com/3.84.0/js/client.min.js"),
+      $.getScript("https://js.braintreegateway.com/3.84.0/js/paypal-checkout.min.js"),
+      $.getScript("https://js.braintreegateway.com/3.84.0/js/data-collector.min.js")
     ).done(function() {
       $("#content").append('<div id="paypal-button"/>');
       $('<script/>').attr({

data/app/assets/stylesheets/spree/frontend/solidus_paypal_braintree.css

@@ -37,3 +37,15 @@ the installer will append this file to the app vendored assets here: 'vendor/ass
 .apple-pay-button.visible {
   visibility: visible;
 }
+
+.venmo-button {
+  visibility: hidden;
+  border: none;
+  height: 48px;
+  background-color: transparent;
+  background-repeat: no-repeat;
+}
+
+.venmo-button.visible {
+  visibility: visible;
+}

data/app/decorators/controllers/solidus_paypal_braintree/admin_payments_controller_decorator.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module SolidusPaypalBraintree
+  module AdminPaymentsControllerDecorator
+    def self.prepended(base)
+      base.helper ::SolidusPaypalBraintree::BraintreeAdminHelper
+    end
+
+    ::Spree::Admin::PaymentsController.prepend(self)
+  end
+end

data/app/decorators/controllers/solidus_paypal_braintree/checkout_controller_decorator.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module SolidusPaypalBraintree
+  module CheckoutControllerDecorator
+    def self.prepended(base)
+      base.helper ::SolidusPaypalBraintree::BraintreeCheckoutHelper
+    end
+
+    ::Spree::CheckoutController.prepend(self) if SolidusSupport.frontend_available?
+  end
+end

data/app/decorators/controllers/solidus_paypal_braintree/client_tokens_controller.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module SolidusPaypalBraintree
+  class ClientTokensController < ::Spree::Api::BaseController
+    skip_before_action :authenticate_user
+
+    before_action :load_gateway
+
+    def create
+      token = @gateway.generate_token
+      if token
+        render json: { client_token: token, payment_method_id: @gateway.id }
+      else
+        render json: { error: Gateway::TOKEN_GENERATION_DISABLED_MESSAGE }, status: :unprocessable_entity
+      end
+    end
+
+    private
+
+    def load_gateway
+      if params[:payment_method_id]
+        @gateway = ::SolidusPaypalBraintree::Gateway.find(params[:payment_method_id])
+      else
+        store_payment_methods_scope =
+          if current_store.payment_methods.empty?
+            ::SolidusPaypalBraintree::Gateway.all
+          else
+            ::SolidusPaypalBraintree::Gateway.where(id: current_store.payment_method_ids)
+          end
+        @gateway = ::SolidusPaypalBraintree::Gateway.where(active: true).merge(store_payment_methods_scope).first!
+      end
+    end
+
+    def generate_token
+      @gateway.generate_token
+    rescue ::SolidusPaypalBraintree::Gateway::TokenGenerationDisabledError => e
+      Rails.logger.error e
+      nil
+    end
+  end
+end

data/app/decorators/controllers/solidus_paypal_braintree/orders_controller_decorator.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module SolidusPaypalBraintree
+  module OrdersControllerDecorator
+    def self.prepended(base)
+      base.helper ::SolidusPaypalBraintree::BraintreeCheckoutHelper
+    end
+
+    ::Spree::OrdersController.prepend(self) if SolidusSupport.frontend_available?
+  end
+end

data/app/decorators/models/solidus_paypal_braintree/spree/store_decorator.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module SolidusPaypalBraintree
+  module Spree
+    module StoreDecorator
+      def self.prepended(base)
+        base.has_one :braintree_configuration, class_name: "SolidusPaypalBraintree::Configuration", dependent: :destroy
+        base.before_create :build_default_configuration
+      end
+
+      private
+
+      def build_default_configuration
+        build_braintree_configuration unless braintree_configuration
+      end
+
+      ::Spree::Store.prepend self
+    end
+  end
+end

data/app/decorators/models/solidus_paypal_braintree/spree/user_decorator.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module SolidusPaypalBraintree
+  module Spree
+    module UserDecorator
+      def self.prepended(base)
+        base.has_one :braintree_customer, class_name: 'SolidusPaypalBraintree::Customer', inverse_of: :user
+      end
+
+      ::Spree.user_class.prepend self
+    end
+  end
+end

data/app/helpers/solidus_paypal_braintree/braintree_admin_helper.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module SolidusPaypalBraintree
+  module BraintreeAdminHelper
+    # Returns a link to the Braintree web UI for the given Braintree payment
+    def braintree_transaction_link(payment)
+      environment = payment.payment_method.preferred_environment == 'sandbox' ? 'sandbox' : 'www'
+      merchant_id = payment.payment_method.preferred_merchant_id
+      response_code = payment.response_code
+
+      return if response_code.blank?
+      return response_code if merchant_id.blank?
+
+      link_to(
+        response_code,
+        "https://#{environment}.braintreegateway.com/merchants/#{merchant_id}/transactions/#{response_code}",
+        title: 'Show payment on Braintree',
+        target: '_blank',
+        rel: 'noopener'
+      )
+    end
+  end
+end

data/app/helpers/solidus_paypal_braintree/braintree_checkout_helper.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module SolidusPaypalBraintree
+  module BraintreeCheckoutHelper
+    def braintree_3ds_options_for(order)
+      ship_address = SolidusPaypalBraintree::Address.new(order.ship_address)
+      bill_address = SolidusPaypalBraintree::Address.new(order.bill_address)
+      {
+        nonce: nil, # populated after tokenization
+        bin: nil, # populated after tokenization
+        onLookupComplete: nil, # populated after tokenization
+        amount: order.total,
+        email: order.email,
+        billingAddress: {
+          givenName: bill_address.firstname,
+          surname: bill_address.lastname,
+          phoneNumber: bill_address.phone,
+          streetAddress: bill_address.address1,
+          extendedAddress: bill_address.address2,
+          locality: bill_address.city,
+          region: bill_address.state&.abbr,
+          postalCode: bill_address.zipcode,
+          countryCodeAlpha2: bill_address.country&.iso,
+        },
+        additionalInformation: {
+          shippingGivenName: ship_address.firstname,
+          shippingSurname: ship_address.lastname,
+          shippingPhone: ship_address.phone,
+          shippingAddress: {
+            streedAddress: ship_address.address1,
+            extendedAddress: ship_address.address2,
+            locality: ship_address.city,
+            region: ship_address.state&.abbr,
+            postalCode: ship_address.zipcode,
+            countryCodeAlpha2: ship_address.country&.iso,
+          }
+        }
+      }
+    end
+
+    def paypal_button_preference(key, store:)
+      store.braintree_configuration.preferences[key]
+    end
+
+    def venmo_button_style(store)
+      configuration = store.braintree_configuration
+      color = configuration.preferred_venmo_button_color
+      width = configuration.preferred_venmo_button_width
+
+      { width: width, color: color }
+    end
+
+    def venmo_button_asset_url(style, active: false)
+      prefix = 'solidus_paypal_braintree/venmo/venmo_'
+      active_string = active ? 'active_' : ''
+      path = "#{prefix}#{active_string}#{style[:color]}_button_#{style[:width]}x48.svg"
+      asset_path(path)
+    end
+  end
+end

data/app/models/application_record.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class ApplicationRecord < ActiveRecord::Base
   self.abstract_class = true
 end

data/app/models/solidus_paypal_braintree/address.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module SolidusPaypalBraintree
+  class Address
+    delegate :address1,
+      :address2,
+      :city,
+      :country,
+      :phone,
+      :state,
+      :zipcode,
+      to: :spree_address
+
+    def self.split_name(name)
+      if defined?(Spree::Address::Name)
+        address_name = Spree::Address::Name.new(name)
+        [address_name.first_name, address_name.last_name]
+      else
+        name.strip.split(' ', 2)
+      end
+    end
+
+    def initialize(spree_address)
+      @spree_address = spree_address
+    end
+
+    def to_json(*_args)
+      address_hash = {
+        line1: address1,
+        line2: address2,
+        city: city,
+        postalCode: zipcode,
+        countryCode: country.iso,
+        phone: phone,
+        recipientName: "#{firstname} #{lastname}"
+      }
+
+      if ::Spree::Config.address_requires_state && country.states_required
+        address_hash[:state] = state.name
+      end
+      address_hash.to_json
+    end
+
+    def firstname
+      if SolidusSupport.combined_first_and_last_name_in_address?
+        self.class.split_name(spree_address.name).first
+      else
+        spree_address.firstname
+      end
+    end
+
+    def lastname
+      if SolidusSupport.combined_first_and_last_name_in_address?
+        self.class.split_name(spree_address.name).last
+      else
+        spree_address.lastname
+      end
+    end
+
+    private
+
+    attr_reader :spree_address
+  end
+end

data/app/models/solidus_paypal_braintree/avs_result.rb

@@ -41,6 +41,9 @@ module SolidusPaypalBraintree
         'I' => 'I',
         'A' => 'I'
       },
+      'B' => {
+        'B' => 'B'
+      },
       nil => { nil => nil }
     }.freeze
 

data/app/models/solidus_paypal_braintree/configuration.rb

@@ -1,5 +1,41 @@
-class SolidusPaypalBraintree::Configuration < ApplicationRecord
-  belongs_to :store, class_name: 'Spree::Store'
+# frozen_string_literal: true
 
-  validates :store, presence: true
+module SolidusPaypalBraintree
+  class Configuration < ::Spree::Base
+    PAYPAL_BUTTON_PREFERENCES = {
+      color: { availables: %w[gold blue silver white black], default: 'white' },
+      shape: { availables: %w[pill rect], default: 'rect' },
+      label: { availables: %w[checkout credit pay buynow paypal installment], default: 'checkout' },
+      tagline: { availables: %w[true false], default: 'false' },
+      layout: { availables: %w[horizontal vertical], default: 'horizontal' },
+      messaging: { availables: %w[true false], default: 'false' }
+    }.freeze
+
+    unless respond_to?(:preference)
+      include ::Spree::Preferences::Persistable
+    end
+
+    belongs_to :store, class_name: 'Spree::Store', optional: false
+
+    # Preferences for Paypal button
+    PAYPAL_BUTTON_PREFERENCES.each do |name, desc|
+      preference_name = "paypal_button_#{name}".to_sym
+      attribute_name = "preferred_#{preference_name}".to_sym
+
+      preference preference_name, :string, default: desc[:default]
+
+      validates attribute_name, inclusion: desc[:availables]
+    end
+
+    preference :venmo_button_color, :preference_select, default: 'blue'
+    preference :venmo_button_width, :preference_select, default: '320'
+
+    def preferred_venmo_button_color_options
+      [["Blue", "blue"], ["White", "white"]]
+    end
+
+    def preferred_venmo_button_width_options
+      [["280", "280"], ["320", "320"], ["375", "375"]]
+    end
+  end
 end

data/app/models/solidus_paypal_braintree/customer.rb

@@ -1,4 +1,8 @@
-class SolidusPaypalBraintree::Customer < ApplicationRecord
-  belongs_to :user, class_name: Spree::UserClassHandle.new
-  has_many :sources, class_name: "SolidusPaypalBraintree::Source", inverse_of: :customer
+# frozen_string_literal: true
+
+module SolidusPaypalBraintree
+  class Customer < ApplicationRecord
+    belongs_to :user, class_name: ::Spree::UserClassHandle.new, optional: true
+    has_many :sources, class_name: "SolidusPaypalBraintree::Source", inverse_of: :customer, dependent: :destroy
+  end
 end