solidus_braintree 1.1.0 → 2.0.0

data/app/controllers/spree/api/braintree_client_token_controller.rb

@@ -1,13 +0,0 @@
-class Spree::Api::BraintreeClientTokenController < Spree::Api::BaseController
-  skip_before_action :authenticate_user
-
-  def create
-    if params[:payment_method_id]
-      gateway = Solidus::Gateway::BraintreeGateway.find_by!(id: params[:payment_method_id])
-    else
-      gateway = Solidus::Gateway::BraintreeGateway.find_by!(active: true)
-    end
-
-    render json: { client_token: gateway.generate_client_token, payment_method_id: gateway.id }
-  end
-end

data/app/helpers/braintree_view_helpers.rb

@@ -1,20 +0,0 @@
-module BraintreeViewHelpers
-  # Returns a link to the Braintree web UI for the given Braintree +payment_id+
-  # (e.g. from Spree::Payment#response_code), or just the +payment_id+ if
-  # Braintree's merchant ID is not configured or +payment_id+ is blank
-  def braintree_transaction_link(payment_id)
-    env = ENV['BRAINTREE_ENV'] == 'production' ? 'www' : 'sandbox'
-    merchant = ENV['BRAINTREE_MERCHANT_ID']
-
-    if payment_id.present? && merchant.present?
-      link_to(
-        payment_id,
-        "https://#{env}.braintreegateway.com/merchants/#{merchant}/transactions/#{payment_id}",
-        title: 'Show payment on Braintree',
-        target: '_blank'
-      )
-    else
-      payment_id
-    end
-  end
-end

data/app/models/concerns/solidus_braintree/add_name_validation_concern.rb

@@ -1,8 +0,0 @@
-module SolidusBraintree
-  module AddNameValidationConcern
-    extend ActiveSupport::Concern
-    included do
-      validates :name, presence: true, on: :create
-    end
-  end
-end

data/app/models/concerns/solidus_braintree/inject_device_data_concern.rb

@@ -1,18 +0,0 @@
-module SolidusBraintree
-  module InjectDeviceDataConcern
-    extend ActiveSupport::Concern
-    included do
-      prepend(InstanceMethods)
-    end
-
-    module InstanceMethods
-      def gateway_options
-        options = super
-
-        options[:device_data] = order.braintree_device_data if order.braintree_device_data
-
-        options
-      end
-    end
-  end
-end

data/app/models/concerns/solidus_braintree/payment_braintree_nonce_concern.rb

@@ -1,8 +0,0 @@
-module SolidusBraintree
-  module PaymentBraintreeNonceConcern
-    extend ActiveSupport::Concern
-    included do
-      attr_accessor :payment_method_nonce
-    end
-  end
-end

data/app/models/concerns/solidus_braintree/permitted_attributes_concern.rb

@@ -1,11 +0,0 @@
-module SolidusBraintree
-  module PermittedAttributesConcern
-    def payment_attributes
-      super | [:payment_method_nonce]
-    end
-
-    def checkout_attributes
-      super | [:braintree_device_data]
-    end
-  end
-end

data/app/models/concerns/solidus_braintree/skip_require_card_numbers_concern.rb

@@ -1,14 +0,0 @@
-module SolidusBraintree
-  module SkipRequireCardNumbersConcern
-    extend ActiveSupport::Concern
-    included do
-      prepend(InstanceMethods)
-    end
-
-    module InstanceMethods
-      def require_card_numbers?
-        super && !self.payment_method.kind_of?(Solidus::Gateway::BraintreeGateway)
-      end
-    end
-  end
-end

data/app/models/concerns/solidus_braintree/use_data_field_concern.rb

@@ -1,23 +0,0 @@
-module SolidusBraintree
-  module UseDataFieldConcern
-    extend ActiveSupport::Concern
-    included do
-      prepend(InstanceMethods)
-    end
-
-    module InstanceMethods
-
-      def email
-        data["email"]
-      end
-
-      def display_number
-        cc_type == 'paypal' ? email : super
-      end
-
-      def data
-        super.is_a?(String) ? JSON.parse(super) : super
-      end
-    end
-  end
-end

data/app/models/credit_card_decorator.rb

@@ -1,3 +0,0 @@
-Spree::CreditCard.include SolidusBraintree::SkipRequireCardNumbersConcern
-Spree::CreditCard.include SolidusBraintree::AddNameValidationConcern
-Spree::CreditCard.include SolidusBraintree::UseDataFieldConcern

data/app/models/payment_decorator.rb

@@ -1,2 +0,0 @@
-Spree::Payment.include SolidusBraintree::PaymentBraintreeNonceConcern
-Spree::Payment.include SolidusBraintree::InjectDeviceDataConcern

data/app/models/permitted_attributes_decorator.rb

@@ -1 +0,0 @@
-Spree::PermittedAttributes.singleton_class.prepend SolidusBraintree::PermittedAttributesConcern

data/app/models/solidus/gateway/braintree_gateway.rb

@@ -1,293 +0,0 @@
-require "braintree"
-
-module Solidus
-  class Gateway::BraintreeGateway < ::Spree::Gateway
-    preference :environment, :string
-    preference :merchant_id, :string
-    preference :public_key, :string
-    preference :private_key, :string
-    preference :always_send_bill_address, :boolean, default: false
-    preference :transmit_shipping_address, :boolean, default: true
-
-    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
-      'braintree'
-    end
-
-    def gateway_options
-      {
-        environment: preferred_environment.to_sym,
-        merchant_id: preferred_merchant_id,
-        public_key: preferred_public_key,
-        private_key: preferred_private_key,
-        logger: ::Braintree::Configuration.logger.clone,
-      }
-    end
-
-    def braintree_gateway
-      @braintree_gateway ||= ::Braintree::Gateway.new(gateway_options)
-    end
-
-    def payment_profiles_supported?
-      true
-    end
-
-    def generate_client_token(options = {})
-      braintree_gateway.client_token.generate(options)
-    end
-
-    def create_profile(payment)
-      source = payment.source
-
-      return if source.gateway_customer_profile_id.present? || payment.payment_method_nonce.nil?
-
-      user = payment.order.user
-      email = user ? user.email : payment.order.email
-      address = (payment.source.address || payment.order.bill_address).try(:active_merchant_hash)
-
-      params = {
-        first_name: source.first_name,
-        last_name: source.last_name,
-        email: email,
-        credit_card: {
-          cardholder_name: source.name,
-          billing_address: map_address(address),
-          payment_method_nonce: payment.payment_method_nonce,
-          options: {
-            verify_card: true,
-          },
-        },
-        device_data: payment.order.braintree_device_data
-      }
-
-      result = braintree_gateway.customer.create(params)
-
-      if result.success?
-        card = result.customer.payment_methods.last
-        source.tap do |solidus_cc|
-          if card.is_a?(::Braintree::PayPalAccount)
-            solidus_cc.cc_type = 'paypal'
-            data = {
-              email: card.email
-            }
-            solidus_cc.data = data.to_json
-          else
-            solidus_cc.name = card.cardholder_name
-            solidus_cc.cc_type = CARD_TYPE_MAPPING[card.card_type]
-            solidus_cc.month = card.expiration_month
-            solidus_cc.year = card.expiration_year
-            solidus_cc.last_digits = card.last_4
-          end
-          solidus_cc.payment_method = self
-          solidus_cc.gateway_customer_profile_id = result.customer.id
-          solidus_cc.gateway_payment_profile_id = card.token
-        end
-        source.save!
-      else
-        raise ::Spree::Core::GatewayError, result.message
-      end
-    end
-
-    def supports?(payment)
-      true
-    end
-
-    def provider_class
-      self
-    end
-
-    def authorize(cents, creditcard, options = {})
-      result = braintree_gateway.transaction.sale(transaction_authorize_or_purchase_params(cents, creditcard, options))
-      handle_result(result)
-    end
-
-    def purchase(cents, creditcard, options = {})
-      params = transaction_authorize_or_purchase_params(cents, creditcard, options)
-      params[:options][:submit_for_settlement] = true
-      result = braintree_gateway.transaction.sale(params)
-      handle_result(result)
-    end
-
-    def capture(money, authorization_code, options = {})
-      result = braintree_gateway.transaction.submit_for_settlement(authorization_code, amount(money))
-      handle_result(result)
-    end
-
-    def void(authorization_code, source = {}, options = {})
-      # Allows voiding payments that are in a checkout state
-      if authorization_code.nil?
-        # Fake response since we don't need to void anything with Braintree
-        ActiveMerchant::Billing::Response.new(
-          true,
-          "OK",
-          {},
-          {}
-        )
-      else
-        result = braintree_gateway.transaction.void(authorization_code)
-        handle_result(result)
-      end
-    end
-
-    def credit(cents, source, authorization_code, options = {})
-      result = braintree_gateway.transaction.refund(authorization_code, amount(cents))
-      handle_result(result)
-    end
-
-    def voidable?(response_code)
-      transaction = braintree_gateway.transaction.find(response_code)
-      [
-        ::Braintree::Transaction::Status::SubmittedForSettlement,
-        ::Braintree::Transaction::Status::Authorized,
-      ].include?(transaction.status)
-    end
-
-    def card_number_placeholder
-      '4141 4141 4141 4141'
-    end
-
-    def expiration_date_placeholder
-      '01/2020'
-    end
-
-    def card_code_placeholder
-      '123'
-    end
-
-    def cancel(response)
-      if voidable?(response)
-        void(response)
-      else
-        handle_result(
-          braintree_gateway.transaction.refund(response)
-        )
-      end
-    end
-
-    private
-    def message_from_result(result)
-      if result.success?
-        "OK"
-      elsif result.errors.count == 0 && result.credit_card_verification
-        "Processor declined: #{result.credit_card_verification.processor_response_text} (#{result.credit_card_verification.processor_response_code})"
-      elsif result.errors.count == 0 && result.transaction
-        result.transaction.status
-      else
-        result.errors.map { |e| "#{e.message} (#{e.code})" }.join(" ")
-      end
-    end
-
-    def build_results_hash(result)
-      if result.success?
-        {
-          authorization: result.transaction.id,
-          avs_result: {
-            code: result.transaction.avs_street_address_response_code
-          }
-        }
-      else
-        {}
-      end
-    end
-
-    def handle_result(result)
-      ActiveMerchant::Billing::Response.new(
-        result.success?,
-        message_from_result(result),
-        {},
-        build_results_hash(result)
-      )
-    end
-
-    def map_address(addr)
-      full_name = addr.fetch(:name, "")
-      *first_name_parts, last_name = full_name.split(" ")
-      first_name = first_name_parts.join(" ")
-      last_name ||= ""
-
-      {
-        first_name: first_name,
-        last_name: last_name,
-        street_address: addr[:address1],
-        extended_address: addr[:address2],
-        locality: addr[:city],
-        region: addr[:state],
-        country_code_alpha2: addr[:country],
-        postal_code: addr[:zip],
-      }
-    end
-
-    def amount(cents)
-      sprintf("%.2f", cents.to_f / 100)
-    end
-
-    def transaction_authorize_or_purchase_params(cents, creditcard, options = {})
-      params = options.select {|k| %i[
-        billing_address_id
-        channel
-        custom_fields
-        descriptor
-        device_data
-        device_session_id
-        merchant_account_id
-        options
-        order_id
-        purchase_order_number
-        recurring
-        service_fee_amount
-        shipping_address_id
-        tax_amount
-        tax_exempt
-      ].include?(k)}
-
-      params[:options] ||= {}
-      params[:amount] = amount(cents)
-      params[:channel] ||= "Solidus"
-      if (options[:shipping_address] && preferred_transmit_shipping_address)
-        params[:shipping] = map_address(options[:shipping_address])
-      end
-
-      if options[:payment_method_nonce]
-        params[:payment_method_nonce] = options[:payment_method_nonce]
-      else
-        params[:payment_method_token] = creditcard.gateway_payment_profile_id
-      end
-
-      # Send the bill address if we're using a nonce (i.e. doing a one-time
-      # payment) or if we're configured to always send the bill address
-      if (
-          options[:payment_method_nonce] || preferred_always_send_bill_address
-        ) && options[:billing_address]
-        params[:billing] = map_address(options[:billing_address])
-      end
-
-      # if has profile, set the customer_id to the profile_id and delete the customer key
-      if creditcard.try(:gateway_customer_profile_id)
-        params[:customer_id] = creditcard.gateway_customer_profile_id
-      # if no profile, define the customer key, delete the customer_id because they are
-      # mutually exclusive
-      else
-        params[:customer] = {
-          id: options[:customer_id],
-          email: options[:customer],
-          first_name: creditcard.first_name,
-          last_name: creditcard.last_name,
-        }
-      end
-
-      params
-    end
-  end
-end

data/app/overrides/spree/checkout/_confirm/braintree_security.html.erb.deface

@@ -1,9 +0,0 @@
-<!-- insert_before "erb[loud]:contains('place_order')" -->
-
-<%
-# Currently we assume we only have one braintree
-# payment method. In practice this should be true and it simplifies the code.
-braintree_payment = @order.unprocessed_payments.find {|p| p.payment_method.class == Solidus::Gateway::BraintreeGateway }
-if braintree_payment %>
-  <%= render 'spree/checkout/payment/braintree_initialization', payment_method: braintree_payment.payment_method %>
-<% end %>

data/app/views/spree/admin/payments/source_forms/_braintree.html.erb

@@ -1,38 +0,0 @@
-<fieldset data-id='credit-card' class="no-border-bottom">
-  <div class="field" data-hook="previous_cards">
-    <% if previous_cards.any? %>
-      <% previous_cards.each do |card| %>
-        <label><%= radio_button_tag :card, card.id, card == previous_cards.first %> <%= card.display_number %><br /></label>
-      <% end %>
-    <% end %>
-    <label><%= radio_button_tag :card, 'new', false, { id: "card_new#{payment_method.id}" } %> <%= Spree.t(:use_new_cc) %></label>
-  </div>
-
-  <div id="card_form<%= payment_method.id %>" data-hook>
-    <% param_prefix = "payment_source[#{payment_method.id}]" %>
-
-    <div class="clear"></div>
-
-    <div class="alpha four columns">
-      <div data-hook="card_name">
-        <div class="field">
-          <%= label_tag "card_name#{payment_method.id}", Spree::CreditCard.human_attribute_name(:name), class: 'required' %>
-          <%= text_field_tag "#{param_prefix}[name]", '', id: "card_name#{payment_method.id}", class: 'required fullwidth', maxlength: 19 %>
-        </div>
-      </div>
-    </div>
-
-    <div id="braintree-dropin"></div>
-    <input type="hidden" id="payment_method_nonce" name="payment[payment_method_nonce]">
-
-    <div class="clear"></div>
-
-    <%= label_tag "card_address#{payment_method.id}", Spree.t(:billing_address) %>
-    <% address = @order.bill_address || @order.ship_address || Spree::Address.build_default %>
-    <%= fields_for "#{param_prefix}[address_attributes]", address do |f| %>
-      <%= render :partial => 'spree/admin/shared/address_form', :locals => { :f => f, :type => "billing" } %>
-    <% end %>
-
-    <div class="clear"></div>
-  </div>
-</fieldset>

data/app/views/spree/admin/payments/source_views/_braintree.html.erb

@@ -1,30 +0,0 @@
-<fieldset data-hook="credit_card">
-  <legend align="center"><%= Spree::CreditCard.model_name.human %></legend>
-
-  <div class="row">
-    <div class="alpha six columns">
-      <dl>
-        <dt><%= Spree.t(:identifier) %>:</dt>
-        <dd><%= payment.number %></dd>
-
-        <dt><%= Spree.t(:response_code) %>:</dt>
-        <dd><%= braintree_transaction_link(payment.response_code) %></dd>
-
-        <dt><%= Spree.t(:name_on_card) %>:</dt>
-        <dd><%= payment.source.name %></dd>
-
-        <dt><%= Spree::CreditCard.human_attribute_name(:cc_type) %>:</dt>
-        <dd><%= payment.source.cc_type %></dd>
-
-        <dt><%= Spree::CreditCard.human_attribute_name(:number) %>:</dt>
-        <dd><%= payment.source.display_number %></dd>
-
-        <dt><%= Spree::CreditCard.human_attribute_name(:expiration) %>:</dt>
-        <dd><%= payment.source.month %>/<%= payment.source.year %></dd>
-      </dl>
-      <% if payment.source.address %>
-        <%= render partial: 'spree/admin/shared/address', locals: {address: payment.source.address} %>
-      <% end %>
-    </div>
-  </div>
-</fieldset>

data/app/views/spree/checkout/payment/_braintree.html.erb

@@ -1,55 +0,0 @@
-<div class="braintree-payment">
-  <%= render 'spree/checkout/payment/braintree_initialization', payment_method: payment_method %>
-
-  <div class="braintree-paypal-input">
-    <div class="braintree-paypal-header">
-      <%= t('solidus_braintree.paypal_header_html') %>
-    </div>
-    <div id="#braintree_paypal_container"></div>
-  </div>
-  
-  <div class="braintree-cc-input">
-    <div class="braintree-cc-header">
-      <%= t('solidus_braintree.creditcard_header_html') %>
-      <%= image_tag 'credit_cards/credit_card.gif', :id => 'credit-card-image' %>
-    </div>
-    <% param_prefix = "payment_source[#{payment_method.id}]" %>
-
-    <p class="field">
-      <%= label_tag "name_on_card_#{payment_method.id}", Spree.t(:name_on_card) %><span class="required">*</span><br />
-      <%= text_field_tag "#{param_prefix}[name]", "#{@order.billing_firstname} #{@order.billing_lastname}", { id: "name_on_card_#{payment_method.id}", :autocomplete => "cc-name" } %>
-    </p>
-
-    <p class="field" data-hook="card_number">
-      <%= label_tag "braintree_card_number", Spree.t(:card_number) %><span class="required">*</span><br />
-      <label for="braintree_card_number" id="braintree_card_number" class="braintree-hosted-field"></label>
-      &nbsp;
-      <span id="card_type" style="display:none;">
-        ( <span id="looks_like" ><%= Spree.t(:card_type_is) %> <span id="type"></span></span>
-        <span id="unrecognized"><%= Spree.t(:unrecognized_card_type) %></span>
-        )
-      </span>
-    </p>
-
-    <p class="field" data-hook="card_expiration">
-      <%= label_tag "braintree_card_expiry", Spree.t(:expiration) %><span class="required">*</span><br />
-      <label for="braintree_card_expiry" id="braintree_card_expiry" class="braintree-hosted-field"></label>
-    </p>
-
-    <p class="field" data-hook="card_code">
-      <%= label_tag "braintree_card_code", Spree.t(:card_code) %><span class="required">*</span><br />
-
-      <label for="braintree_card_code" id="braintree_card_code" class="braintree-hosted-field card-code"></label>
-      <%= link_to "(#{Spree.t(:what_is_this)})", spree.cvv_path, :target => '_blank', "data-hook" => "cvv_link", :id => "cvv_link" %>
-    </p>
-  </div>
-
-  <% if @order.bill_address %>
-    <%= fields_for "#{param_prefix}[address_attributes]", @order.bill_address do |f| %>
-      <%= render :partial => 'spree/address/form_hidden', :locals => { :form => f } %>
-    <% end %>
-  <% end %>
-
-  <%= hidden_field_tag "#{param_prefix}[cc_type]", '', :id => "cc_type", :class => 'ccType' %>
-  <%= hidden_field_tag "order[payments_attributes][][payment_method_nonce]", '', :id => "payment_method_nonce" %>
-</div>

data/app/views/spree/checkout/payment/_braintree_initialization.html.erb

@@ -1,12 +0,0 @@
-<% content_for :head do %>
-  <%= javascript_tag do %>
-    braintree.environment = "<%= payment_method.preferred_environment %>"
-    braintree.placeholders = {
-      "number": "<%= payment_method.card_number_placeholder %>",
-      "expirationDate": "<%= payment_method.expiration_date_placeholder %>",
-      "cvv": "<%= payment_method.card_code_placeholder %>"
-    }
-  <% end %>
-<% end %>
-
-<%= hidden_field_tag "order[braintree_device_data]", '', :id => "device_data" %>

data/config/initializers/braintree.rb

@@ -1 +0,0 @@
-ActionView::Base.send :include, BraintreeViewHelpers

data/db/migrate/20150910170527_add_data_to_credit_card.rb

@@ -1,5 +0,0 @@
-class AddDataToCreditCard < ActiveRecord::Migration
-  def change
-    add_column :spree_credit_cards, :data, :text
-  end
-end

data/db/migrate/20160426221931_add_braintree_device_data_to_order.rb

@@ -1,5 +0,0 @@
-class AddBraintreeDeviceDataToOrder < ActiveRecord::Migration
-  def change
-    add_column :spree_orders, :braintree_device_data, :text
-  end
-end

data/lib/assets/javascripts/spree/backend/braintree/solidus_braintree.js

@@ -1,59 +0,0 @@
-//= require "vendor/braintree"
-
-Spree.routes.payment_client_token_api = Spree.pathFor("api/payment_client_token")
-
-var braintreeDropinIntegration;
-var paymentForm = "#new_payment";
-var cardSelector = "#new_payment [name=card]";
-
-var getClientToken = function(onSuccess) {
-  return Spree.ajax({
-    url: Spree.routes.payment_client_token_api,
-    type: "POST",
-    data: {
-      payment_method_id: $('form input[type=radio]:checked').val()
-    },
-    error: function(xhr, status) {
-      show_flash("error", xhr.responseJSON.message);
-    },
-    success: function(data) {
-      onSuccess(data);
-    }
-  });
-};
-
-var attachDropIn = function(data) {
-  braintree.setup(data.client_token, "dropin", {
-    container: "braintree-dropin",
-    form: "new_payment",
-    onReady: function (integration) {
-      braintreeDropinIntegration = integration;
-    },
-    onError: function(type, message) {
-      show_flash("error", message);
-    },
-    onPaymentMethodReceived: function(obj) {
-      $("#payment_method_nonce").val(obj.nonce);
-      $("#new_payment").submit();
-      return;
-    }
-  });
-};
-
-$(document).ready(function() {
-  if ($(paymentForm).length) {
-    if ($(cardSelector).length) {
-      $(cardSelector).on("change", function() {
-        if ($(cardSelector + ":checked").val() === "new") {
-          getClientToken(attachDropIn);
-        } else {
-          if (braintreeDropinIntegration) {
-            braintreeDropinIntegration.teardown();
-          }
-        }
-      });
-    } else {
-      getClientToken(attachDropIn);
-    }
-  }
-});