solidus_gateway 0.9.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8ce4994806351d5327bf00d2f9bf191338bbeecb
+  data.tar.gz: c5bbc490c8db7133c29e686a9d0bb76e201863ca
+SHA512:
+  metadata.gz: 5470ee6c4a91f27f7ad7ba187ab7978f879331f3ea6235520ed3940988432a3b3ac81b132371ea1e261e3ce0ad0bec3ae5041cd99aadd6dc794f7e98f29c6fa7
+  data.tar.gz: 158ab601aa3a283aefe1b5f21b40b8e2de54c3fccb701dc3271bc2d467a8d5849fd8f2ecfa5b1a036ec1ab3e4c1e2766b33f8d528205a3503587510f0a708b85

data/.gitignore

@@ -0,0 +1,11 @@
+\#*
+*~
+.#*
+.DS_Store
+tmp
+spec/dummy
+Gemfile.lock
+.rvmrc
+coverage
+.ruby-version
+pkg

data/.rspec

@@ -0,0 +1 @@
+--colour

data/.travis.yml

@@ -0,0 +1,23 @@
+language: ruby
+before_script:
+  - sh -e /etc/init.d/xvfb start
+  - export DISPLAY=:99.0
+  - bundle exec rake test_app
+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"
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.2

data/Gemfile

@@ -0,0 +1,9 @@
+source "https://rubygems.org"
+
+gem "solidus", github: "solidusio/solidus", branch: "v1.0"
+
+group :development, :test do
+  gem "pry-rails"
+end
+
+gemspec

data/LICENSE.md

@@ -0,0 +1,26 @@
+Copyright (c) 2014 Spree Commerce Inc. and other contributors.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright notice,
+      this list of conditions and the following disclaimer in the documentation
+      and/or other materials provided with the distribution.
+    * Neither the name Spree nor the names of its contributors may be used to
+      endorse or promote products derived from this software without specific
+      prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,38 @@
+Solidus Gateway
+===============
+
+Community supported Solidus 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.
+
+Installation
+------------
+
+In your Gemfile:
+
+```ruby
+gem "solidus_gateway"
+```
+
+Then run from the command line:
+
+```shell
+bundle install
+rails g solidus_gateway:install
+```
+
+Finally, make sure to **restart your app**. Navigate to *Configuration >
+Payment Methods > New Payment Method* in the admin panel and you should see
+that a bunch of additional gateways have been added to the list.
+
+Testing
+-------
+
+Then just run the following to automatically build a dummy app if necessary and
+run the tests:
+
+```shell
+bundle exec rake
+```

data/Rakefile

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

data/app/models/spree/billing_integration/skrill/quick_checkout.rb

@@ -0,0 +1,48 @@
+module Spree
+  class BillingIntegration::Skrill::QuickCheckout < BillingIntegration
+    preference :merchant_id, :string
+    preference :language, :string, :default => 'EN'
+    preference :currency, :string, :default => 'EUR'
+    preference :payment_options, :string, :default => 'ACC'
+    preference :pay_to_email, :string ,   :default => 'your@merchant.email_here'
+
+    def provider_class
+      ActiveMerchant::Billing::Skrill
+    end
+
+    def redirect_url(order, opts = {})
+      opts.merge! self.preferences
+
+      set_global_options(opts)
+
+      opts[:detail1_text] = order.number
+      opts[:detail1_description] = "Order:"
+
+      opts[:pay_from_email] = order.email
+      opts[:firstname] = order.bill_address.firstname
+      opts[:lastname] = order.bill_address.lastname
+      opts[:address] = order.bill_address.address1
+      opts[:address2] = order.bill_address.address2
+      opts[:phone_number] = order.bill_address.phone.gsub(/\D/,'') if order.bill_address.phone
+      opts[:city] = order.bill_address.city
+      opts[:postal_code] = order.bill_address.zipcode
+      opts[:state] = order.bill_address.state.nil? ? order.bill_address.state_name.to_s : order.bill_address.state.abbr
+      opts[:country] = order.bill_address.country.name
+      opts[:pay_to_email] = self.preferred_pay_to_email
+      opts[:hide_login] = 1
+      opts[:merchant_fields] = 'platform,order_id,payment_method_id'
+      opts[:platform] = 'Spree'
+      opts[:order_id] = order.number
+
+      skrill = self.provider
+      skrill.payment_url(opts)
+    end
+
+    private
+      def set_global_options(opts)
+        opts[:recipient_description] = Spree::Config[:site_name]
+        opts[:payment_methods] = self.preferred_payment_options
+      end
+
+  end
+end

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

@@ -0,0 +1,31 @@
+module Spree
+  class Gateway::AuthorizeNet < Gateway
+    preference :login, :string
+    preference :password, :string
+
+    def provider_class
+      ActiveMerchant::Billing::AuthorizeNetGateway
+    end
+
+    def options_with_test_preference
+      options_without_test_preference.merge(test: self.preferred_test_mode)
+    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

@@ -0,0 +1,201 @@
+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
+
+    def provider_class
+      self.class
+    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.preferences[:test] = true
+      else
+        self.preferences.delete(:test)
+      end
+
+      super
+    end
+
+    def authorize(amount, creditcard, gateway_options)
+      create_transaction(amount, creditcard, :auth_only, transaction_options(gateway_options))
+    end
+
+    def purchase(amount, creditcard, gateway_options)
+      create_transaction(amount, creditcard, :auth_capture, transaction_options(gateway_options))
+    end
+
+    # 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, transaction_options(gateway_options).merge(trans_id: response_code))
+    end
+
+    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. 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])
+      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
+
+    # 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 = {})
+        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.update({
+          customer_profile_id: creditcard.gateway_customer_profile_id,
+          customer_payment_profile_id: creditcard.gateway_payment_profile_id
+        }) if creditcard
+
+        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
+
+      # Create a new CIM customer profile ready to accept a payment
+      def create_customer_profile(payment)
+        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 }
+        else
+          payment.send(:gateway_error, response)
+        end
+      end
+
+      def options_for_create_customer_profile(payment)
+        if payment.is_a? CreditCard
+          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 } }
+        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(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
+        }
+      end
+
+      def cim_gateway
+        @_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

@@ -0,0 +1,65 @@
+module Spree
+  class Gateway::BalancedGateway < Gateway
+    preference :login, :string
+    preference :on_behalf_of_uri, :string
+
+    def authorize(money, creditcard, gateway_options)
+      if token = creditcard.gateway_payment_profile_id
+        # The Balanced ActiveMerchant gateway supports passing the token directly as the creditcard parameter
+        creditcard = token
+      end
+      provider.authorize(money, creditcard, gateway_options)
+    end
+
+    def capture(authorization, creditcard, gateway_options)
+      gateway_options[:on_behalf_of_uri] = self.preferred_on_behalf_of_uri
+      provider.capture((authorization.amount * 100).round, authorization.response_code, gateway_options)
+    end
+
+    def create_profile(payment)
+      return unless payment.source.gateway_payment_profile_id.nil?
+
+      options = {}
+      options[:email] = payment.order.email
+      options[:login] = preferred_login
+
+      card_store_response = provider.store(payment.source, options)
+      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.
+      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
+      options_without_test_preference.merge(:test => self.preferred_test_mode)
+    end
+    alias_method_chain :options, :test_preference
+
+    def payment_profiles_supported?
+      true
+    end
+
+    def purchase(money, creditcard, gateway_options)
+      if token = creditcard.gateway_payment_profile_id
+        # The Balanced ActiveMerchant gateway supports passing the token directly as the creditcard parameter
+        creditcard = token
+      end
+      provider.purchase(money, creditcard, gateway_options)
+    end
+
+    def provider_class
+      ActiveMerchant::Billing::BalancedGateway
+    end
+
+    def credit(money, creditcard, response_code, gateway_options)
+      provider.refund(money, response_code, {})
+    end
+
+    def void(response_code, creditcard, gateway_options)
+      provider.void(response_code)
+    end
+
+  end
+end