spree_gateway 2.2.1 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 95c7ba85f1dc043286f155159fb7b99920b5380c
-  data.tar.gz: 0b3b9ea6327a6dd7e9bd178da097d4328806520b
+  metadata.gz: 0cb78725c48779b76c00a60061c407ee89c83f7c
+  data.tar.gz: 1a0480cb3b860dd2b93b3dcb1b1f29de35f62881
 SHA512:
-  metadata.gz: f8ae2294899c1db7f01b118c7a627233bb16653bef5878e7e9b4ca50521ebc9b1a86e05f45bf2b43c3fea2e6dee6315ac4087caad57d58e19dc5f31dd0f30949
-  data.tar.gz: 460ffbd59ecea4aef14c93a052dc1ef011d8c1f48ae95c88213a4dcf05209071f7600ecb8a4cbaa05eabcbae136f5b1dab0bf004208da574e590a047dafa7f0a
+  metadata.gz: 5f2750bae6c95b1e2017c9eebb9a9c4a21c0210e972cf3d9a3a96fdab474bfe4c92f264f2e7174d7513ae6a9365d1b09dc3ba71b097f6d5c725796e9f3227c08
+  data.tar.gz: 35898a84a069e3ee90bdb97f77f155bc53208dc581b8c2cbef016d1214a1616c9d58dfff450d67154ed55cb2a704168670cb0721283645f41744d7ebcdfbb358

data/.travis.yml

@@ -1,23 +1,11 @@
-language: ruby
 before_script:
-  - sh -e /etc/init.d/xvfb start
-  - export DISPLAY=:99.0
   - bundle exec rake test_app
+  - export DISPLAY=:99.0
+  - sh -e /etc/init.d/xvfb start
 env:
-  - DB=sqlite
   - DB=mysql
   - DB=postgres
-script:
-  - bundle exec rspec spec
-notifications:
-  email:
-    - ryan@spreecommerce.com
-  irc:
-    use_notice: true
-    skip_join: true
-    channels:
-      - "irc.freenode.org#spree"
+language: ruby
 rvm:
-  - 1.9.3
-  - 2.0.0
-  - 2.1.0
+  - 2.1
+sudo: false

data/Gemfile

@@ -1,5 +1,5 @@
 source 'https://rubygems.org'
 
-gem 'spree', github: 'spree/spree', branch: '2-2-stable'
+gem 'spree', github: 'spree/spree', branch: '3-0-stable'
 
 gemspec

data/README.md

@@ -3,7 +3,11 @@
 [![Build Status](https://api.travis-ci.org/spree/spree_gateway.png?branch=master)](https://travis-ci.org/spree/spree_gateway)
 [![Code Climate](https://codeclimate.com/github/spree/spree_gateway.png)](https://codeclimate.com/github/spree/spree_gateway)
 
-Community supported Spree Payment Method Gateways.
+Community supported Spree Payment Method Gateways. It works as a wrapper for
+active_merchant gateway. Note that for some gateways you might still need to
+add another gem to your Gemfile to make it work. For example active_merchant
+require `braintree` but it doesn't include that gem on its gemspec. So you
+need to manually add it to your rails app Gemfile.
 
 These can be used with Spree >= 1.0.x (but see note below for necessary changes)
 
@@ -27,8 +31,6 @@ gem 'spree', '~> 1.3'
 gem 'spree_gateway', github: 'spree/spree_gateway', branch: '1-3-stable'
 ```
 
-**Note:** *Please consult the Versionfile at the root of the repository to determine which branch to use.*
-
 Then run from the command line:
 
     $ bundle install
@@ -56,12 +58,16 @@ Starting point:
 
 * Fork the repo
 * Clone your repo
+* (You will need to `brew install mysql postgres` if you don't already have them installed)
 * Run `bundle`
+* (You may need to `bundle update` if bundler gets stuck)
 * Run `bundle exec rake test_app` to create the test application in `spec/test_app`
 * Make your changes
 * Ensure specs pass by running `bundle exec rspec spec`
+* (You will need to `brew install phantomjs` if you don't already have it installed)
 * Submit your pull request
 
+
 Copyright (c) 2014 [Spree Commerce][4] and other [contributors][5], released under the [New BSD License][3]
 
 [1]: http://www.fsf.org/licensing/essays/free-sw.html

data/app/models/spree/billing_integration.rb

@@ -0,0 +1,21 @@
+module Spree
+  class BillingIntegration < PaymentMethod
+    validates :name, presence: true
+
+    preference :server, :string, default: 'test'
+    preference :test_mode, :boolean, default: true
+
+    def provider
+      integration_options = options
+      ActiveMerchant::Billing::Base.integration_mode = integration_options[:server].to_sym
+      integration_options[:test] = true if integration_options[:test_mode]
+      @provider ||= provider_class.new(integration_options)
+    end
+
+    def options
+      options_hash = {}
+      preferences.each { |key, value| options_hash[key.to_sym] = value }
+      options_hash
+    end
+  end
+end

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

@@ -2,15 +2,45 @@ module Spree
   class Gateway::AuthorizeNet < Gateway
     preference :login, :string
     preference :password, :string
+    preference :server, :string, default: "test"
 
     def provider_class
       ActiveMerchant::Billing::AuthorizeNetGateway
     end
 
     def options_with_test_preference
-      options_without_test_preference.merge(:test => self.preferred_test_mode)
+      if !['live','test'].include?(self.preferred_server)
+        raise "You must set the 'server' preference in your payment method (Gateway::AuthorizeNet) to either 'live' or 'test'"
+      end
+      options_without_test_preference.merge(test: (self.preferred_server != "live") )
     end
 
+    def cancel(response_code)
+      provider
+      # From: http://community.developer.authorize.net/t5/The-Authorize-Net-Developer-Blog/Refunds-in-Retail-A-user-friendly-approach-using-AIM/ba-p/9848
+      # DD: if unsettled, void needed
+      response = provider.void(response_code)
+      # DD: if settled, credit/refund needed (CAN'T DO WITHOUT CREDIT CARD ON AUTH.NET)
+      #response = provider.refund(response_code) unless response.success?
+
+      response
+    end
     alias_method_chain :options, :test_preference
+
+    def credit(amount, response_code, refund, gateway_options = {})
+      gateway_options[:card_number] = refund[:originator].payment.source.last_digits
+      auth_net_gateway.refund(amount, response_code, gateway_options)
+    end
+
+    private
+
+    def auth_net_gateway
+      @_auth_net_gateway ||= begin
+        ActiveMerchant::Billing::Base.gateway_mode = preferred_server.to_sym
+        gateway_options = options
+        gateway_options[:test_requests] = false # DD: never ever do test requests because just returns transaction_id = 0
+        ActiveMerchant::Billing::AuthorizeNetGateway.new(gateway_options)
+      end
+    end
   end
 end

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

@@ -2,8 +2,9 @@ module Spree
   class Gateway::AuthorizeNetCim < Gateway
     preference :login, :string
     preference :password, :string
-    preference :test_mode, :boolean, :default => false
-    preference :validate_on_profile_create, :boolean, :default => false
+    preference :server, :string, default: "test"
+    preference :test_mode, :boolean, default: false
+    preference :validate_on_profile_create, :boolean, default: false
 
     ActiveMerchant::Billing::Response.class_eval do
       attr_writer :authorization
@@ -14,76 +15,142 @@ module Spree
     end
 
     def options
-      # add :test key in the options hash, as that is what the ActiveMerchant::Billing::AuthorizeNetGateway expects
-      if self.preferred_test_mode
-        self.class.preference :test, :boolean, :default => true
+      if !['live','test'].include?(self.preferred_server)
+        raise "You must set the 'server' preference in your payment method (Gateway::AuthorizeNetCim) to either 'live' or 'test'"
+      end
+
+      # add :test key in the options hash, as that is what the
+      # ActiveMerchant::Billing::AuthorizeNetGateway expects
+      if self.preferred_server != "live"
+        self.preferences[:test] = true
       else
-        self.class.remove_preference :test
+        self.preferences.delete(:test)
       end
 
       super
     end
 
     def authorize(amount, creditcard, gateway_options)
-      t_options = { :order => {:invoice_number => gateway_options[:order_id] } }
-       create_transaction( amount, creditcard, :auth_only, t_options )
+      create_transaction(amount, creditcard, :auth_only, transaction_options(gateway_options))
     end
 
     def purchase(amount, creditcard, gateway_options)
-      create_transaction(amount, creditcard, :auth_capture)
+      create_transaction(amount, creditcard, :auth_capture, transaction_options(gateway_options))
     end
 
-    def capture(authorization, creditcard, gateway_options)
-      create_transaction((authorization.amount * 100).round, creditcard, :prior_auth_capture, :trans_id => authorization.response_code)
+    # capture is only one where source is not passed in for payment profile
+    def capture(amount, response_code, gateway_options)
+      # no credit card needed
+      create_transaction(amount, nil, :prior_auth_capture, trans_id: response_code)
     end
 
-    def credit(amount, creditcard, response_code, gateway_options)
-      create_transaction(amount, creditcard, :refund, :trans_id => response_code)
+    def credit(amount, creditcard, response_code, gateway_options = {})
+      create_transaction(amount, creditcard, :refund, transaction_options(gateway_options).merge(trans_id: response_code))
     end
 
-    def void(response_code, creditcard, gateway_options)
-      create_transaction(nil, creditcard, :void, :trans_id => response_code)
+    def void(response_code, creditcard, gateway_options = {})
+      create_transaction(nil, creditcard, :void, transaction_options(gateway_options).merge(trans_id: response_code))
+    end
+
+    def cancel(response_code)
+      # From: http://community.developer.authorize.net/t5/The-Authorize-Net-Developer-Blog/Refunds-in-Retail-A-user-friendly-approach-using-AIM/ba-p/9848
+      # DD: if unsettled, void needed
+      response = void(response_code, nil)
+      # DD: if settled, credit/refund needed
+      response = credit(nil, nil, response_code) unless response.success?
+
+      response
     end
 
     def payment_profiles_supported?
       true
     end
 
-    # Create a new CIM customer profile ready to accept a payment
+    # Create a new CIM customer profile ready to accept a payment. Called by Spree::Payment on after_save.
     def create_profile(payment)
       if payment.source.gateway_customer_profile_id.nil?
         profile_hash = create_customer_profile(payment)
-        payment.source.update_attributes(:gateway_customer_profile_id => profile_hash[:customer_profile_id], :gateway_payment_profile_id => profile_hash[:customer_payment_profile_id])
+        payment.source.update_attributes(gateway_customer_profile_id: profile_hash[:customer_profile_id], gateway_payment_profile_id: profile_hash[:customer_payment_profile_id])
+      end
+    end
+
+    # Get the CIM payment profile; Needed for updates.
+    def get_profile(payment)
+      if payment.source.has_payment_profile?
+        profile = cim_gateway.get_customer_profile({
+          customer_profile_id: payment.source.gateway_customer_profile_id
+        })
+        if profile
+          profile.params['profile'].deep_symbolize_keys!
+        end
       end
     end
 
-    # simpler form
-    def create_profile_from_card(card)
-      if card.gateway_customer_profile_id.nil?
-        profile_hash = create_customer_profile(card)
-        card.update_attributes(:gateway_customer_profile_id => profile_hash[:customer_profile_id], :gateway_payment_profile_id => profile_hash[:customer_payment_profile_id])
+    # Get the CIM payment profile; Needed for updates.
+    def get_payment_profile(payment)
+      if payment.source.has_payment_profile?
+        profile = cim_gateway.get_customer_payment_profile({
+          customer_profile_id: payment.source.gateway_customer_profile_id,
+          customer_payment_profile_id: payment.source.gateway_payment_profile_id
+        })
+        if profile
+          profile.params['payment_profile'].deep_symbolize_keys!
+        end
+      end
+    end
+
+    # Update billing address on the CIM payment profile
+    def update_payment_profile(payment)
+      if payment.source.has_payment_profile?
+        if hash = get_payment_profile(payment)
+          hash[:bill_to] = generate_address_hash(payment.order.bill_address)
+          if hash[:payment][:credit_card]
+            # activemerchant expects a credit card object with 'number', 'year', 'month', and 'verification_value?' defined
+            payment.source.define_singleton_method(:number) { "XXXXXXXXX#{payment.source.last_digits}" }
+            hash[:payment][:credit_card] = payment.source
+          end
+          cim_gateway.update_customer_payment_profile({
+            customer_profile_id: payment.source.gateway_customer_profile_id,
+            payment_profile: hash
+          })
+        end
       end
     end
 
     private
+
+      def transaction_options(gateway_options = {})
+        { order: { invoice_number: gateway_options[:order_id] } }
+      end
+
       # Create a transaction on a creditcard
       # Set up a CIM profile for the card if one doesn't exist
       # Valid transaction_types are :auth_only, :capture_only and :auth_capture
       def create_transaction(amount, creditcard, transaction_type, options = {})
-        #create_profile(creditcard, creditcard.gateway_options)
-        creditcard.save
+        creditcard.save if creditcard
+
+        transaction_options = {
+          type: transaction_type
+        }.update(options)
+
         if amount
           amount = "%.2f" % (amount / 100.0) # This gateway requires formated decimal, not cents
+          transaction_options.update({
+            amount: amount
+          })
         end
-        transaction_options = {
-          :type => transaction_type,
-          :amount => amount,
-          :customer_profile_id => creditcard.gateway_customer_profile_id,
-          :customer_payment_profile_id => creditcard.gateway_payment_profile_id,
-        }.update(options)
-        t = cim_gateway.create_customer_profile_transaction(:transaction => transaction_options)
-        logger.debug("\nAuthorize Net CIM Transaction")
+
+        if creditcard
+          transaction_options.update({
+            customer_profile_id: creditcard.gateway_customer_profile_id,
+            customer_payment_profile_id: creditcard.gateway_payment_profile_id
+          })
+        end
+
+        logger.debug("\nAuthorize Net CIM Request")
         logger.debug("  transaction_options: #{transaction_options.inspect}")
+        t = cim_gateway.create_customer_profile_transaction(transaction: transaction_options)
+        logger.debug("\nAuthorize Net CIM Response")
         logger.debug("  response: #{t.inspect}\n")
         t
       end
@@ -93,8 +160,8 @@ module Spree
         options = options_for_create_customer_profile(payment)
         response = cim_gateway.create_customer_profile(options)
         if response.success?
-          { :customer_profile_id => response.params['customer_profile_id'],
-            :customer_payment_profile_id => response.params['customer_payment_profile_id_list'].values.first }
+          { customer_profile_id: response.params['customer_profile_id'],
+            customer_payment_profile_id: response.params['customer_payment_profile_id_list'].values.first }
         else
           payment.send(:gateway_error, response)
         end
@@ -102,31 +169,45 @@ module Spree
 
       def options_for_create_customer_profile(payment)
         if payment.is_a? CreditCard
-          info = { :bill_to => generate_address_hash(payment.address), :payment => { :credit_card => payment } }
+          info = { bill_to: generate_address_hash(payment.address),
+                   payment: { credit_card: payment } }
         else
-          info = { :bill_to => generate_address_hash(payment.order.bill_address),
-                   :payment => { :credit_card => payment.source } }
+          info = { bill_to: generate_address_hash(payment.order.bill_address),
+                   payment: { credit_card: payment.source } }
         end
         validation_mode = preferred_validate_on_profile_create ? preferred_server.to_sym : :none
 
-        { :profile => { :merchant_customer_id => "#{Time.now.to_f}",
-                        #:ship_to_list => generate_address_hash(creditcard.checkout.ship_address),
-                        :email => payment.order.email,
-                        :payment_profiles => info },
-          :validation_mode => validation_mode }
+        { profile: { merchant_customer_id: "#{Time.now.to_f}",
+                     ship_to_list: generate_address_hash(payment.order.ship_address),
+                     email: payment.order.email,
+                     payment_profiles: info },
+          validation_mode: validation_mode }
       end
 
       # As in PaymentGateway but with separate name fields
       def generate_address_hash(address)
         return {} if address.nil?
-        {:first_name => address.firstname, :last_name => address.lastname, :address1 => address.address1, :address2 => address.address2, :city => address.city,
-         :state => address.state_text, :zip => address.zipcode, :country => address.country.iso, :phone_number => address.phone}
+        {
+          first_name: address.firstname,
+          last_name: address.lastname,
+          address1: address.address1,
+          address2: address.address2,
+          city: address.city,
+          state: address.state_text,
+          zip: address.zipcode,
+          country: address.country.iso,
+          phone_number: address.phone
+        }
       end
 
       def cim_gateway
-        ActiveMerchant::Billing::Base.gateway_mode = preferred_server.to_sym
-        gateway_options = options
-        ActiveMerchant::Billing::AuthorizeNetCimGateway.new(gateway_options)
+        @_cim_gateway ||= begin
+          ActiveMerchant::Billing::Base.gateway_mode = preferred_server.to_sym
+          gateway_options = options
+          gateway_options[:test_requests] = false # DD: never ever do test requests because just returns transaction_id = 0
+          ActiveMerchant::Billing::AuthorizeNetCimGateway.new(gateway_options)
+        end
       end
+
   end
 end

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

@@ -27,11 +27,9 @@ module Spree
       card_uri = card_store_response.authorization.split(';').first
 
       # A success just returns a string of the token. A failed request returns a bad request response with a message.
-      if card_uri.is_a?(String)
-        payment.source.update_attributes!(:gateway_payment_profile_id => card_uri)
-      else
-        payment.send(:gateway_error, card_uri.message)
-      end
+      payment.source.update_attributes!(:gateway_payment_profile_id => card_uri)
+    rescue Error => ex
+      payment.send(:gateway_error, ex.message)
     end
 
     def options_with_test_preference

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

@@ -37,18 +37,25 @@ module Spree
 
     def authorize(money, creditcard, options = {})
       adjust_options_for_braintree(creditcard, options)
-      payment_method = creditcard.gateway_customer_profile_id || creditcard
+
+      if creditcard.gateway_payment_profile_id
+        payment_method = creditcard.gateway_payment_profile_id
+        options[:payment_method_token] = true
+      else
+        payment_method = creditcard.gateway_customer_profile_id || creditcard
+      end
+
       provider.authorize(money, payment_method, options)
     end
 
-    def capture(authorization, ignored_creditcard, ignored_options)
-      amount = (authorization.amount * 100).to_i
-      provider.capture(amount, authorization.response_code)
+    def capture(amount, authorization_code, ignored_options = {})
+      provider.capture(amount, authorization_code)
     end
 
     def create_profile(payment)
-      if payment.source.gateway_customer_profile_id.nil?
-        response = provider.store(payment.source)
+      if payment.source.gateway_customer_profile_id.nil? && payment.source.number.present?
+        response = provider.store(payment.source, options_for_payment(payment))
+
         if response.success?
           payment.source.update_attributes!(:gateway_customer_profile_id => response.params['customer_vault_id'])
           cc = response.params['braintree_customer'].fetch('credit_cards',[]).first
@@ -118,18 +125,17 @@ module Spree
       h
     end
 
-    def preferences
-      preferences = super.slice(:merchant_id,
-                                :merchant_account_id,
-                                :public_key,
-                                :private_key,
-                                :client_side_encryption_key,
-                                :environment)
-
-      # Must be either :production or :sandbox, not their string equivalents.
-      # Thanks to the Braintree gem.
-      preferences[:environment] = preferences[:environment].try(:to_sym) || :sandbox
-      preferences
+    def cancel(response_code)
+      provider
+      transaction = ::Braintree::Transaction.find(response_code)
+      # From: https://www.braintreepayments.com/docs/ruby/transactions/refund
+      # "A transaction can be refunded if its status is settled or settling.
+      # If the transaction has not yet begun settlement, it should be voided instead of refunded.
+      if transaction.status == Braintree::Transaction::Status::SubmittedForSettlement
+        provider.void(response_code)
+      else
+        provider.refund(response_code)
+      end
     end
 
     protected
@@ -143,5 +149,36 @@ module Spree
       def adjust_options_for_braintree(creditcard, options)
         adjust_billing_address(creditcard, options)
       end
+
+      def options_for_payment(p)
+        o = Hash.new
+        o[:email] = p.order.email
+
+        if p.source.gateway_customer_profile_id.present?
+          o[:customer] = p.source.gateway_customer_profile_id
+        end
+
+        if p.order.bill_address
+          bill_addr = p.order.bill_address
+
+          o[:first_name] = bill_addr.firstname
+          o[:last_name] = bill_addr.lastname
+
+          o[:billing_address] = {
+            address1: bill_addr.address1,
+            address2: bill_addr.address2,
+            company: bill_addr.company,
+            city: bill_addr.city,
+            state: bill_addr.state ? bill_addr.state.name : bill_addr.state_name,
+            country_code_alpha3: bill_addr.country.iso3,
+            zip: bill_addr.zipcode
+          }
+        end
+
+        o[:verify_card] = "true"
+
+        return o
+      end
+
   end
 end