solidus_braintree 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: af19cf56975489c4e80eb66b7cacce68f025d395
+  data.tar.gz: 3a2a4764fbe429a4029fa6818dadf017fe244d1a
+SHA512:
+  metadata.gz: 96f6ea5668b4858ee83862fe80191fd2c654ba91eb846d90879acd0721a8085215f86c82c9c12c3248f9b12f04c3d3c21da4038da7fa32937d6ebb21d21df275
+  data.tar.gz: f9ef7734bd60bfa523e73a87eb47f13e6e8c5a8885fea7234b570366e5ffadba94c28d3d46b6a9b15a7260be3fa2155733ee3a1d1cb5c45b9861a29213c20114

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/spec/dummy

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.1.6
+before_install: gem install bundler -v 1.10.5

data/Gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in solidus_braintree.gemspec
+#gem "solidus", github: "solidusio/solidus", branch: "master"
+gemspec

data/Guardfile

@@ -0,0 +1,70 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+## Uncomment and set this to only include directories you want to watch
+# directories %w(app lib config test spec features) \
+#  .select{|d| Dir.exists?(d) ? d : UI.warning("Directory #{d} does not exist")}
+
+## Note: if you are using the `directories` clause above and you are not
+## watching the project directory ('.'), then you will want to move
+## the Guardfile to a watched dir and symlink it back, e.g.
+#
+#  $ mkdir config
+#  $ mv Guardfile config/
+#  $ ln -s config/Guardfile .
+#
+# and, you'll have to watch "config/Guardfile" instead of "Guardfile"
+
+# Note: The cmd option is now required due to the increasing number of ways
+#       rspec may be run, below are examples of the most common uses.
+#  * bundler: 'bundle exec rspec'
+#  * bundler binstubs: 'bin/rspec'
+#  * spring: 'bin/rspec' (This will use spring if running and you have
+#                          installed the spring binstubs per the docs)
+#  * zeus: 'zeus rspec' (requires the server to be started separately)
+#  * 'just' rspec: 'rspec'
+
+guard :rspec, cmd: "bundle exec rspec" do
+  require "guard/rspec/dsl"
+  dsl = Guard::RSpec::Dsl.new(self)
+
+  # Feel free to open issues for suggestions and improvements
+
+  # RSpec files
+  rspec = dsl.rspec
+  watch(rspec.spec_helper) { rspec.spec_dir }
+  watch(rspec.spec_support) { rspec.spec_dir }
+  watch(rspec.spec_files)
+
+  # Ruby files
+  ruby = dsl.ruby
+  dsl.watch_spec_files_for(ruby.lib_files)
+
+  # Rails files
+  rails = dsl.rails(view_extensions: %w(erb haml slim))
+  dsl.watch_spec_files_for(rails.app_files)
+  dsl.watch_spec_files_for(rails.views)
+
+  watch(rails.controllers) do |m|
+    [
+      rspec.spec.("routing/#{m[1]}_routing"),
+      rspec.spec.("controllers/#{m[1]}_controller"),
+      rspec.spec.("acceptance/#{m[1]}")
+    ]
+  end
+
+  # Rails config changes
+  watch(rails.spec_helper)     { rspec.spec_dir }
+  watch(rails.routes)          { "#{rspec.spec_dir}/routing" }
+  watch(rails.app_controller)  { "#{rspec.spec_dir}/controllers" }
+
+  # Capybara features specs
+  watch(rails.view_dirs)     { |m| rspec.spec.("features/#{m[1]}") }
+  watch(rails.layouts)       { |m| rspec.spec.("features/#{m[1]}") }
+
+  # Turnip features and steps
+  watch(%r{^spec/acceptance/(.+)\.feature$})
+  watch(%r{^spec/acceptance/steps/(.+)_steps\.rb$}) do |m|
+    Dir[File.join("**/#{m[1]}.feature")][0] || "spec/acceptance"
+  end
+end

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Jack Chu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,41 @@
+# SolidusBraintree
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/solidus_braintree`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'solidus_braintree'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install solidus_braintree
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake rspec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/solidus_braintree.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,15 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+require 'spree/testing_support/common_rake'
+
+RSpec::Core::RakeTask.new(:spec)
+
+Bundler::GemHelper.install_tasks
+
+task default: :spec
+
+desc "Generates a dummy app for testing"
+task :test_app do
+  ENV['LIB_NAME'] = 'solidus_braintree'
+  Rake::Task['common:test_app'].invoke
+end

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

@@ -0,0 +1,11 @@
+class Spree::Api::BraintreeClientTokenController < Spree::Api::BaseController
+  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/models/concerns/payment_braintree_nonce_concern.rb

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

data/app/models/concerns/permitted_attributes_concern.rb

@@ -0,0 +1,5 @@
+module PermittedAttributesConcern
+  def payment_attributes
+    super | [:payment_method_nonce]
+  end
+end

data/app/models/concerns/skip_require_card_numbers_concern.rb

@@ -0,0 +1,12 @@
+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

data/app/models/credit_card_decorator.rb

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

data/app/models/payment_decorator.rb

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

data/app/models/permitted_attributes_decorator.rb

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

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

@@ -0,0 +1,227 @@
+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
+
+    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 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
+      address = (payment.source.address || payment.order.bill_address).try(:active_merchant_hash)
+
+      params = {
+        first_name: source.first_name,
+        last_name: source.last_name,
+        email: user.email,
+        credit_card: {
+          cardholder_name: source.name,
+          billing_address: map_address(address),
+          payment_method_nonce: payment.payment_method_nonce,
+          options: {
+            verify_card: true,
+          },
+        },
+      }
+
+      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'
+            solidus_cc.name = card.email
+          else
+            solidus_cc.name = card.cardholder_name
+            solidus_cc.cc_type = card.card_type.downcase
+            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 = {})
+      result = braintree_gateway.transaction.void(authorization_code)
+
+      handle_result(result)
+    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
+
+    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 handle_result(result)
+      ActiveMerchant::Billing::Response.new(
+        result.success?,
+        message_from_result(result),
+        {},
+        { authorization: (result.transaction.id if result.success?) }
+      )
+    end
+
+    def map_address(addr)
+      {
+        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"
+      params[:shipping] = map_address(options[:shipping_address]) if options[:shipping_address]
+
+      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
+        params[:billing] = map_address(options[:billing_address]) if 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