archetype_spree_gateway 3.9.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f5d09441469ac5dede82534c51cabe9f81584cb3c07909c852e1fb08101574b1
+  data.tar.gz: 319f475d119d8b552201331626935ce439c4dc9199e738c779df2f19d8cbd696
+SHA512:
+  metadata.gz: 99d8aaec4ffd482c9dfc52e6873222ed604b36c5cd03c6a0ce5df80a465740ca1dba779d5337eae27b84b6b96f5cfe3d091000c769c410f475115afbe3bfb6fd
+  data.tar.gz: 0f32987262dc458ce2e662cd1286cf0f90dc5ed5ee354a9fd8267522da99374ea6e0389edbec07d964fc0f33eb2571c83280a41c75979ece41155b90dc388365

data/.gitignore

@@ -0,0 +1,21 @@
+\#*
+*~
+.#*
+.DS_Store
+.idea
+.localeapp/locales
+.project
+coverage
+default
+Gemfile.lock
+tmp
+nbproject
+pkg
+*.sw?
+spec/dummy
+.rvmrc
+.sass-cache
+public/spree
+.ruby-version
+.ruby-gemset
+gemfiles/*.gemfile.lock

data/.rspec

@@ -0,0 +1,3 @@
+--color
+-r spec_helper
+-f documentation

data/.travis.yml

@@ -0,0 +1,39 @@
+os: linux
+dist: bionic
+
+cache: bundler
+
+addons:
+  apt:
+    sources:
+      - google-chrome
+    packages:
+      - google-chrome-stable
+
+services:
+  - mysql
+  - postgresql
+  - redis-server
+
+language: ruby
+
+rvm:
+  - 2.7
+  - 3.0
+
+env:
+  - DB=mysql
+  - DB=postgres
+
+before_install:
+  - mysql -u root -e "GRANT ALL ON *.* TO 'travis'@'%';"
+
+before_script:
+  - CHROME_MAIN_VERSION=`google-chrome-stable --version | sed -E 's/(^Google Chrome |\.[0-9]+ )//g'`
+  - CHROMEDRIVER_VERSION=`curl -s "https://chromedriver.storage.googleapis.com/LATEST_RELEASE_$CHROME_MAIN_VERSION"`
+  - curl "https://chromedriver.storage.googleapis.com/${CHROMEDRIVER_VERSION}/chromedriver_linux64.zip" -O
+  - unzip chromedriver_linux64.zip -d ~/bin
+
+script:
+  - bundle exec rake test_app
+  - bundle exec rake spec

data/Gemfile

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+
+gem 'rails-controller-testing'
+gem 'spree', github: 'spree/spree', branch: 'main'
+gem 'spree_backend', github: 'spree/spree_backend', branch: 'main'
+gem 'spree_frontend', github: 'spree/spree_legacy_frontend', branch: 'main'
+gem 'activemerchant', github: 'archetype2142/active-merchant', branch: 'master'
+
+gemspec

data/Guardfile

@@ -0,0 +1,9 @@
+guard "rspec", cmd: "bundle exec rspec", all_after_pass: false, all_on_start: false do
+  watch("spec/spec_helper.rb")                        { "spec" }
+  watch("config/routes.rb")                           { "spec/controllers" }
+  watch(%r{^spec/(.+)_spec\.rb$})                     { |m| "spec/#{m[1]}_spec.rb"}
+  watch(%r{^app/(.+)\.rb$})                           { |m| "spec/#{m[1]}_spec.rb" }
+  watch(%r{^app/(.*)\.erb$})                          { |m| "spec/#{m[1]}#{m[2]}_spec.rb" }
+  watch(%r{^lib/(.+)\.rb$})                           { |m| "spec/#{m[1]}_spec.rb" }
+  watch(%r{^app/controllers/(.+)_(controller)\.rb$})  { |m| "spec/#{m[2]}s/#{m[1]}_#{m[2]}_spec.rb" }
+end

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,105 @@
+# Spree Gateway
+
+[![Build Status](https://api.travis-ci.org/spree/spree_gateway.svg?branch=main)](https://travis-ci.org/spree/spree_gateway)
+[![Code Climate](https://codeclimate.com/github/spree/spree_gateway.svg)](https://codeclimate.com/github/spree/spree_gateway)
+
+Community supported Spree Payment Method Gateways. It works as a wrapper for
+[active_merchant](https://github.com/activemerchant/active_merchant) gateway. 
+
+Supported payment gateways:
+* Authorize.net (with CIM support)
+* Apple Pay (via Stripe)
+* BanWire
+* Bambora (previously Beanstream)
+* Braintree
+* CyberSource
+* ePay
+* eWay
+* maxipago
+* MasterCard Payment Gateway Service (formerly MiGS)
+* Moneris
+* PayJunction
+* Payflow
+* Paymill
+* Pin Payments
+* QuickPay
+* sage Pay
+* SecurePay
+* Spreedly
+* Stripe (with Stripe Elements)
+* USAePay
+* Worldpay (previously Cardsave)
+
+For`PayPal` support head over to [braintree_vzero](https://github.com/spree-contrib/spree_braintree_vzero) extension.
+
+## Installation
+
+1. Add this extension to your Gemfile with this line:
+
+    ```ruby
+    gem 'spree_gateway', '~> 3.7'
+    ```
+
+2. Install the gem using Bundler:
+    ```ruby
+    bundle install
+    ```
+
+3. Copy & run migrations
+    ```ruby
+    bundle exec rails g spree_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.
+
+## Contributing
+
+In the spirit of [free software][1], **everyone** is encouraged to help improve this project.
+
+Here are some ways *you* can contribute:
+
+* by using prerelease versions
+* by reporting [bugs][2]
+* by suggesting new features
+* by writing or editing documentation
+* by writing specifications
+* by writing code (*no patch is too small*: fix typos, add comments, clean up inconsistent whitespace)
+* by refactoring code
+* by resolving [issues][2]
+* by reviewing patches
+
+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
+
+
+License
+----------------------
+
+Spree is released under the [New BSD License][3].
+
+About Spark Solutions
+----------------------
+[![Spark Solutions](http://sparksolutions.co/wp-content/uploads/2015/01/logo-ss-tr-221x100.png)][spark]
+
+Spree Gateway is maintained by [Spark Solutions Sp. z o.o.][spark].
+
+We are passionate about open source software.
+We are [available for hire][spark].
+
+[spark]:http://sparksolutions.co?utm_source=github
+
+[1]: http://www.fsf.org/licensing/essays/free-sw.html
+[2]: https://github.com/spree/spree_gateway/issues
+[3]: https://github.com/spree/spree_gateway/blob/main/LICENSE.md
+[4]: https://github.com/spree
+[5]: https://github.com/spree/spree_gateway/graphs/contributors

data/Rakefile

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

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/check.rb

@@ -0,0 +1,41 @@
+module Spree
+  class Check < Spree::Base
+
+    attr_accessor :imported
+
+    belongs_to :payment_method
+    belongs_to :user, class_name: Spree.user_class.to_s, foreign_key: 'user_id',
+               optional: true
+    has_many :payments, as: :source
+
+    scope :with_payment_profile, -> { where.not(gateway_customer_profile_id: nil) }
+
+    validates :account_holder_name, presence: true
+    validates :account_holder_type, presence: true, inclusion: { in: %w[Individual Company] }
+    validates :account_number, presence: true, numericality: { only_integer: true }
+    validates :routing_number, presence: true, numericality: { only_integer: true }
+
+    def has_payment_profile?
+      gateway_customer_profile_id.present? || gateway_payment_profile_id.present?
+    end
+
+    def actions
+      %w[capture void credit]
+    end
+
+    def can_capture?(payment)
+      payment.pending? || payment.checkout?
+    end
+
+    # Indicates whether its possible to void the payment.
+    def can_void?(payment)
+      !payment.failed? && !payment.void?
+    end
+
+    # Indicates whether its possible to credit the payment.  Note that most gateways require that the
+    # payment be settled first which generally happens within 12-24 hours of the transaction.
+    def can_credit?(payment)
+      payment.completed? && payment.credit_allowed > 0
+    end
+  end
+end

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

@@ -0,0 +1,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
+      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
+      super().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
+
+    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,213 @@
+module Spree
+  class Gateway::AuthorizeNetCim < Gateway
+    preference :login, :string
+    preference :password, :string
+    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
+    end
+
+    def provider_class
+      self.class
+    end
+
+    def options
+      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.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(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
+
+        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
+
+      # 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,64 @@
+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!(:gateway_payment_profile_id => card_uri)
+    rescue Error => ex
+      payment.send(:gateway_error, ex.message)
+    end
+
+    def options
+      super().merge(:test => self.preferred_test_mode)
+    end
+
+    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

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

@@ -0,0 +1,15 @@
+module Spree
+  class Gateway::Banwire < Gateway
+    preference :login, :string
+
+
+    def provider_class
+      ActiveMerchant::Billing::BanwireGateway
+    end
+
+    def purchase(money, creditcard, gateway_options)
+      gateway_options[:description] = "Spree Order"
+      provider.purchase(money, creditcard, gateway_options)
+    end
+  end
+end