solidus_gateway 0.9.0

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

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

@@ -0,0 +1,193 @@
+module Spree
+  class Gateway::Beanstream < Gateway
+    preference :login, :string
+    preference :user, :string
+    preference :password, :string
+    preference :secure_profile_api_key, :string
+
+    def provider_class
+      ActiveMerchant::Billing::BeanstreamGateway
+    end
+
+    def payment_profiles_supported?
+      true
+    end
+
+    def create_profile(payment)
+      creditcard = payment.source
+      if creditcard.gateway_customer_profile_id.nil?
+        options = options_for_create_customer_profile(creditcard, {})
+        verify_creditcard_name!(creditcard)
+        result = provider.store(creditcard, options)
+        if result.success?
+          creditcard.update_attributes(:gateway_customer_profile_id => result.params['customerCode'], :gateway_payment_profile_id => result.params['customer_vault_id'])
+        else
+          payment.send(:gateway_error, result)
+        end
+      end
+    end
+
+    def capture(transaction, creditcard, gateway_options)
+      beanstream_gateway.capture((transaction.amount*100).round, transaction.response_code, gateway_options)
+    end
+
+    def void(transaction_response, creditcard, gateway_options)
+      beanstream_gateway.void(transaction_response, gateway_options)
+    end
+
+    def credit(amount, creditcard, response_code, gateway_options = {})
+      amount = (amount * -1) if amount < 0
+      beanstream_gateway.credit(amount, response_code, gateway_options)
+    end
+
+    private
+      def beanstream_gateway
+        ActiveMerchant::Billing::Base.gateway_mode = preferred_server.to_sym
+        gateway_options = options
+        ActiveMerchant::Billing::BeanstreamGateway.new(gateway_options)
+      end
+
+      def verify_creditcard_name!(creditcard)
+        bill_address = creditcard.payments.first.order.bill_address
+        creditcard.first_name = bill_address.firstname unless creditcard.first_name?
+        creditcard.last_name = bill_address.lastname   unless creditcard.last_name?
+      end
+
+      def options_for_create_customer_profile(creditcard, gateway_options)
+        order = creditcard.payments.first.order
+        address = order.bill_address
+        { :email=>order.email,
+          :billing_address=>
+          { :name=>address.full_name,
+            :phone=>address.phone,
+            :address1=>address.address1,
+            :address2=>address.address2,
+            :city=>address.city,
+            :state=>address.state_name || address.state.abbr,
+            :country=>address.country.iso,
+            :zip=>address.zipcode
+            }
+          }.merge(gateway_options)
+      end
+
+      SECURE_PROFILE_URL = 'https://www.beanstream.com/scripts/payment_profile.asp'
+      SP_SERVICE_VERSION = '1.1'
+      PROFILE_OPERATIONS = { :new => 'N', :modify => 'M' }
+
+      ActiveMerchant::Billing::BeanstreamGateway.class_eval do
+
+        def store(credit_card, options = {})
+          post = {}
+          add_address(post, options)
+          add_credit_card(post, credit_card)
+          add_secure_profile_variables(post,options)
+          commit(post, true)
+        end
+
+        #can't actually delete a secure profile with the supplicaed API. This function sets the status of the profile to closed (C).
+        #Closed profiles will have to removed manually.
+        def delete(vault_id)
+          update(vault_id, false, { :status => 'C' })
+        end
+
+        #alias_method :unstore, :delete
+
+        # Update the values (such as CC expiration) stored at
+        # the gateway.  The CC number must be supplied in the
+        # CreditCard object.
+        def update(vault_id, credit_card, options = {})
+          post = {}
+          add_address(post, options)
+          add_credit_card(post, credit_card)
+          options.merge!({ :vault_id => vault_id, :operation => secure_profile_action(:modify) })
+          add_secure_profile_variables(post,options)
+          commit(post, true)
+        end
+
+        # CORE #
+
+        def secure_profile_action(type)
+          PROFILE_OPERATIONS[type] || PROFILE_OPERATIONS[:new]
+        end
+
+        def add_credit_card(post, credit_card)
+          if credit_card
+            if credit_card.has_payment_profile?
+              post[:customerCode] = credit_card.gateway_customer_profile_id
+            else
+              post[:trnCardOwner] = credit_card.name
+              post[:trnCardNumber] = credit_card.number
+              post[:trnExpMonth] = format(credit_card.month, :two_digits)
+              post[:trnExpYear] = format(credit_card.year, :two_digits)
+              post[:trnCardCvd] = credit_card.verification_value
+            end
+          end
+        end
+
+        def add_secure_profile_variables(post, options = {})
+          post[:serviceVersion] = SP_SERVICE_VERSION
+          post[:responseFormat] = 'QS'
+          post[:cardValidation] = (options[:cardValidation].to_i == 1) || '0'
+
+          post[:operationType] = options[:operationType] || options[:operation] || secure_profile_action(:new)
+          post[:customerCode] = options[:billing_id] || options[:vault_id] || false
+          post[:status] = options[:status]
+        end
+
+        def commit(params, use_profile_api = false)
+          post(post_data(params,use_profile_api),use_profile_api)
+        end
+
+        def post(data, use_profile_api)
+          response = parse(ssl_post((use_profile_api ? SECURE_PROFILE_URL : ActiveMerchant::Billing::BeanstreamGateway::URL), data))
+          if response[:responseCode].eql?("17") # Found matching card
+            response[:responseCode] = "1"
+            response[:customerCode] = response[:matchedCustomerCode]
+          end
+          response[:customer_vault_id] = response[:customerCode] if response[:customerCode]
+          build_response(success?(response), message_from(response), response,
+                         :test => test? || response[:authCode] == 'TEST',
+                         :authorization => authorization_from(response),
+                         :cvv_result => ActiveMerchant::Billing::BeanstreamGateway::CVD_CODES[response[:cvdId]],
+                         :avs_result => { :code => (ActiveMerchant::Billing::BeanstreamGateway::AVS_CODES.include? response[:avsId]) ? ActiveMerchant::Billing::BeanstreamGateway::AVS_CODES[response[:avsId]] : response[:avsId] }
+                         )
+        end
+
+        def message_from(response)
+          response[:messageText] || response[:responseMessage]
+        end
+
+        def success?(response)
+          response[:responseType] == 'R' || response[:trnApproved] == '1' || response[:responseCode] == '1'
+        end
+
+        def add_source(post, source)
+          if source.is_a?(String) or source.is_a?(Integer)
+            post[:customerCode] = source
+          else
+            if source.respond_to?(:type) && source.type.to_s == 'check'
+              add_check(post, source)
+            else
+              add_credit_card(post, source)
+            end
+          end
+        end
+
+        def post_data(params, use_profile_api)
+          params[:requestType] = 'BACKEND'
+          if use_profile_api
+            params[:merchantId] = @options[:login]
+            params[:passCode] = @options[:secure_profile_api_key]
+          else
+            params[:username] = @options[:user] if @options[:user]
+            params[:password] = @options[:password] if @options[:password]
+            params[:merchant_id] = @options[:login]
+          end
+          params[:vbvEnabled] = '0'
+          params[:scEnabled] = '0'
+
+          params.reject { |k, v| v.blank? }.collect { |key, value| "#{key}=#{CGI.escape(value.to_s)}" }.join('&')
+        end
+      end
+  end
+end

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

@@ -0,0 +1,184 @@
+module Spree
+  class Gateway::BraintreeGateway < Gateway
+    preference :environment, :string
+    preference :merchant_id, :string
+    preference :merchant_account_id, :string
+    preference :public_key, :string
+    preference :private_key, :string
+    preference :client_side_encryption_key, :text
+
+    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 provider
+      provider_instance = super
+      Braintree::Configuration.custom_user_agent = "Spree #{Spree.version}"
+      Braintree::Configuration.environment = preferred_environment.to_sym
+      Braintree::Configuration.merchant_id = preferred_merchant_id
+      Braintree::Configuration.public_key = preferred_public_key
+      Braintree::Configuration.private_key = preferred_private_key
+
+      provider_instance
+    end
+
+    def provider_class
+      ActiveMerchant::Billing::BraintreeBlueGateway
+    end
+
+    def authorize(money, creditcard, options = {})
+      adjust_options_for_braintree(creditcard, options)
+
+      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(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, 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
+          update_card_number(payment.source, cc) if cc
+        else
+          payment.send(:gateway_error, response.message)
+        end
+      end
+    end
+
+    def update_card_number(source, cc)
+      last_4 = cc['last_4']
+      source.last_digits = last_4 if last_4
+      source.gateway_payment_profile_id = cc['token']
+      source.cc_type = CARD_TYPE_MAPPING[cc['card_type']] if cc['card_type']
+      source.save!
+    end
+
+    def credit(*args)
+      if args.size == 4
+        # enables ability to refund instead of credit
+        args.slice!(1,1)
+        credit_without_payment_profiles(*args)
+      elsif args.size == 3
+        credit_without_payment_profiles(*args)
+      else
+        raise ArgumentError, "Expected 3 or 4 arguments, received #{args.size}"
+      end
+    end
+
+    # Braintree now disables credits by default, see https://www.braintreepayments.com/docs/ruby/transactions/credit
+    def credit_with_payment_profiles(amount, payment, response_code, option)
+      provider.credit(amount, payment)
+    end
+
+    def credit_without_payment_profiles(amount, response_code, options)
+      provider # braintree provider needs to be called here to properly configure braintree gem.
+      transaction = ::Braintree::Transaction.find(response_code)
+      if BigDecimal.new(amount.to_s) == (transaction.amount * 100)
+        provider.refund(response_code)
+      elsif BigDecimal.new(amount.to_s) < (transaction.amount * 100) # support partial refunds
+        provider.refund(amount, response_code)
+      else
+        raise NotImplementedError
+      end
+    end
+
+    def payment_profiles_supported?
+      true
+    end
+
+    def purchase(money, creditcard, options = {})
+      authorize(money, creditcard, options.merge(:submit_for_settlement => true))
+    end
+
+    def void(response_code, *ignored_options)
+      provider.void(response_code)
+    end
+
+    def options
+      h = super
+      # We need to add merchant_account_id only if present when creating BraintreeBlueGateway
+      # Remove it since it is always part of the preferences hash.
+      if h[:merchant_account_id].blank?
+        h.delete(:merchant_account_id)
+      end
+      h
+    end
+
+    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
+
+      def adjust_billing_address(creditcard, options)
+        if creditcard.gateway_customer_profile_id
+          options.delete(:billing_address)
+        end
+      end
+
+      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

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

@@ -0,0 +1,10 @@
+module Spree
+  class Gateway::CardSave < Gateway
+    preference :login, :string
+    preference :password, :string
+
+    def provider_class
+      ActiveMerchant::Billing::CardSaveGateway
+    end
+  end
+end

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

@@ -0,0 +1,10 @@
+module Spree
+  class Gateway::DataCash < Gateway
+    preference :login, :string
+    preference :password, :string
+
+    def provider_class
+      ActiveMerchant::Billing::DataCashGateway
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module Spree
+  class Gateway::Eway < Gateway
+    preference :login, :string
+
+    # Note: EWay supports purchase method only (no authorize method).
+    def auto_capture?
+      true
+    end
+
+    def provider_class
+      ActiveMerchant::Billing::EwayGateway
+    end
+
+    def options_with_test_preference
+      options_without_test_preference.merge(:test => self.preferred_test_mode)
+    end
+
+    alias_method_chain :options, :test_preference
+  end
+end

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

@@ -0,0 +1,28 @@
+module Spree
+  class Gateway::Linkpoint < Gateway
+    preference :login, :string
+    preference :pem, :text
+
+    def provider_class
+      ActiveMerchant::Billing::LinkpointGateway
+    end
+
+    [:authorize, :purchase, :capture, :void, :credit].each do |method|
+      define_method(method) do |*args|
+        options = add_discount_to_subtotal(args.extract_options!)
+        provider.public_send(method, *args << options)
+      end
+    end
+
+    private
+
+    # Linkpoint ignores the discount, but it will return an error if the
+    # chargetotal is different from the sum of the subtotal, tax and
+    # shipping totals.
+    def add_discount_to_subtotal(options)
+      subtotal = options.fetch(:subtotal)
+      discount = options.fetch(:discount)
+      options.merge(subtotal: subtotal + discount, discount: 0)
+    end
+  end
+end