start_activemerchant 1.50.0

data/lib/active_merchant/billing/gateways/ideal/ideal_rabobank.pem

@@ -0,0 +1,13 @@
+-----BEGIN CERTIFICATE-----
+MIICQDCCAakCBELvbPYwDQYJKoZIhvcNAQEEBQAwZzELMAkGA1UEBhMCREUxDzANBgNVBAgTBkhl
+c3NlbjESMBAGA1UEBxMJRnJhbmtmdXJ0MQ4wDAYDVQQKEwVpREVBTDEOMAwGA1UECxMFaURFQUwx
+EzARBgNVBAMTCmlERUFMIFJhYm8wHhcNMDUwODAyMTI1NDE0WhcNMTUwNzMxMTI1NDE0WjBnMQsw
+CQYDVQQGEwJERTEPMA0GA1UECBMGSGVzc2VuMRIwEAYDVQQHEwlGcmFua2Z1cnQxDjAMBgNVBAoT
+BWlERUFMMQ4wDAYDVQQLEwVpREVBTDETMBEGA1UEAxMKaURFQUwgUmFibzCBnzANBgkqhkiG9w0B
+AQEFAAOBjQAwgYkCgYEA486iIKVhr8RNjxH+PZ3yTWx/8k2fqDFm8XU8I1Z5esRmPFnXmlgA8cG7
+e9AaBPaLoP7Dc8dRQoUO66KMakzGI/WAVdHIJiiKrz8xOcioIgrzPSqec7aqse3J28UraEHkGESJ
+7dAW7Pw/shrmpmkzKsunLt6AkXss4W3JUndZUN0CAwEAATANBgkqhkiG9w0BAQQFAAOBgQCGy/FK
+Lotp2ZOTtuLMgvDy74eicq/Znv4bLfpglzAPHycRHcHsXuer/lNHyvpKf2gdYe+IFalUW3OJZWIM
+jpm4UniJ16RPdgwWVRJEdPr/P7JXMIqD2IEOgujuuTQ7x0VgCf9XrsPsP9ZR5DIPcDDhbrpSE0yF
+Do77nwG61xMaGA==
+-----END CERTIFICATE-----

data/lib/active_merchant/billing/gateways/ideal/ideal_response.rb

@@ -0,0 +1,29 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class IdealResponse < Response
+
+      def issuer_list      
+        list = @params.values[0]['Directory']['Issuer']
+        case list
+          when Hash
+            return [list]
+          when Array
+            return list
+        end  
+      end
+      
+      def service_url
+        @params.values[0]['Issuer']['issuerAuthenticationURL']
+      end
+      
+      def transaction
+        @params.values[0]['Transaction']
+      end
+      
+      def error
+        @params.values[0]['Error']
+      end
+      
+    end
+  end
+end

data/lib/active_merchant/billing/gateways/ideal_rabobank.rb

@@ -0,0 +1,66 @@
+require 'active_merchant/billing/gateways/ideal/ideal_base'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    # First, make sure you have everything setup correctly and all of your dependencies in place with:
+    #
+    #    require 'rubygems'
+    #    require 'active_merchant'
+    #
+    # ActiveMerchant expects the amounts to be given as an Integer in cents. In this case, 10 EUR becomes 1000.
+    #
+    # Create certificates for authentication:
+    #
+    # The PEM file expected should contain both the certificate and the generated PEM file.
+    # Some sample shell commands to generate the certificates:
+    #
+    #    openssl genrsa -aes128 -out priv.pem -passout pass:[YOUR PASSWORD] 1024
+    #    openssl req -x509 -new -key priv.pem -passin pass:[YOUR PASSWORD] -days 3000 -out cert.cer
+    #    cat cert.cer priv.pem > ideal.pem
+    #
+    # Following the steps above, upload cert.cer to the ideal web interface and pass the path of ideal.pem to the :pem option.
+    #
+    # Configure the gateway using your iDEAL bank account info and security settings:
+    #
+    # Create gateway:
+    #    gateway = ActiveMerchant::Billing::IdealRabobankGateway.new(
+    #      :login    => '123456789', # 9 digit merchant number
+    #      :pem      => File.read(Rails.root + 'config/ideal.pem'),
+    #      :password => 'password' # password for the PEM key
+    #    )
+    #
+    # Get list of issuers to fill selection list on your payment form:
+    #    response = gateway.issuers
+    #    list = response.issuer_list
+    #
+    # Request transaction:
+    #
+    #    options = {
+    #       :issuer_id         => '0001',
+    #       :expiration_period => 'PT10M',
+    #       :return_url        => 'http://www.return.url',
+    #       :order_id          => '1234567890123456',
+    #       :currency          => 'EUR',
+    #       :description       => 'Een omschrijving',
+    #       :entrance_code     => '1234'
+    #    }
+    #
+    #    response = gateway.setup_purchase(amount, options)
+    #    transaction_id = response.transaction['transactionID']
+    #    redirect_url = response.service_url
+    #
+    # Mandatory status request will confirm transaction:
+    #    response = gateway.capture(transaction_id)
+    #
+    # Implementation contains some simplifications
+    # - does not support multiple subID per merchant
+    # - language is fixed to 'nl'
+    class IdealRabobankGateway < IdealBaseGateway
+      class_attribute :test_url, :live_url
+
+      self.test_url = 'https://idealtest.rabobank.nl/ideal/iDeal'
+      self.live_url = 'https://ideal.rabobank.nl/ideal/iDeal'
+      self.server_pem = File.read(File.dirname(__FILE__) + '/ideal/ideal_rabobank.pem')
+    end
+  end
+end

data/lib/active_merchant/billing/gateways/inspire.rb

@@ -0,0 +1,219 @@
+require File.join(File.dirname(__FILE__), '..', 'check.rb')
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class InspireGateway < Gateway
+      self.live_url = self.test_url = 'https://secure.inspiregateway.net/api/transact.php'
+
+      self.supported_countries = ['US']
+      self.supported_cardtypes = [:visa, :master, :american_express]
+      self.homepage_url = 'http://www.inspiregateway.com'
+      self.display_name = 'Inspire Commerce'
+
+      # Creates a new InspireGateway
+      #
+      # The gateway requires that a valid login and password be passed
+      # in the +options+ hash.
+      #
+      # ==== Options
+      #
+      # * <tt>:login</tt> -- The Inspire Username.
+      # * <tt>:password</tt> -- The Inspire Passowrd.
+      # See the Inspire Integration Guide for details. (default: +false+)
+      def initialize(options = {})
+        requires!(options, :login, :password)
+        super
+      end
+
+      # Pass :store => true in the options to store the
+      # payment info at Inspire Gateway and get a generated
+      # customer_vault_id in the response.
+      # Pass :store => some_number_or_string to specify the
+      # customer_vault_id InspireGateway should use (make sure it's
+      # unique).
+      def authorize(money, creditcard, options = {})
+        post = {}
+        add_invoice(post, options)
+        add_payment_source(post, creditcard,options)
+        add_address(post, creditcard, options)
+        add_customer_data(post, options)
+
+        commit('auth', money, post)
+      end
+
+      def purchase(money, payment_source, options = {})
+        post = {}
+        add_invoice(post, options)
+        add_payment_source(post, payment_source, options)
+        add_address(post, payment_source, options)
+        add_customer_data(post, options)
+
+        commit('sale', money, post)
+      end
+
+      def capture(money, authorization, options = {})
+        post ={}
+        post[:transactionid] = authorization
+        commit('capture', money, post)
+      end
+
+      def void(authorization, options = {})
+        post ={}
+        post[:transactionid] = authorization
+        commit('void', nil, post)
+      end
+
+      def refund(money, authorization, options = {})
+        post = {}
+        post[:transactionid] = authorization
+        commit('refund', money, post)
+      end
+
+      # Update the values (such as CC expiration) stored at
+      # InspireGateway.  The CC number must be supplied in the
+      # CreditCard object.
+      def update(vault_id, creditcard, options = {})
+        post = {}
+        post[:customer_vault] = "update_customer"
+        add_customer_vault_id(post, vault_id)
+        add_creditcard(post, creditcard, options)
+        add_address(post, creditcard, options)
+        add_customer_data(post, options)
+
+        commit(nil, nil, post)
+      end
+
+      def delete(vault_id)
+        post = {}
+        post[:customer_vault] = "delete_customer"
+        add_customer_vault_id(post, vault_id)
+        commit(nil, nil, post)
+      end
+
+      # To match the other stored-value gateways, like TrustCommerce,
+      # store and unstore need to be defined
+      def store(creditcard, options = {})
+        billing_id = options.delete(:billing_id).to_s || true
+        authorize(100, creditcard, options.merge(:store => billing_id))
+      end
+
+      alias_method :unstore, :delete
+
+      private
+      def add_customer_data(post, options)
+        if options.has_key? :email
+          post[:email] = options[:email]
+        end
+
+        if options.has_key? :ip
+          post[:ipaddress] = options[:ip]
+        end
+      end
+
+      def add_address(post, creditcard, options)
+        if address = options[:billing_address] || options[:address]
+          post[:address1]    = address[:address1].to_s
+          post[:address2]    = address[:address2].to_s unless address[:address2].blank?
+          post[:company]    = address[:company].to_s
+          post[:phone]      = address[:phone].to_s
+          post[:zip]        = address[:zip].to_s
+          post[:city]       = address[:city].to_s
+          post[:country]    = address[:country].to_s
+          post[:state]      = address[:state].blank?  ? 'n/a' : address[:state]
+        end
+      end
+
+      def add_invoice(post, options)
+        post[:orderid] = options[:order_id].to_s.gsub(/[^\w.]/, '')
+        post[:orderdescription] = options[:description]
+      end
+
+      def add_payment_source(params, source, options={})
+        case determine_funding_source(source)
+        when :vault       then add_customer_vault_id(params, source)
+        when :credit_card then add_creditcard(params, source, options)
+        when :check       then add_check(params, source)
+        end
+      end
+
+      def add_customer_vault_id(params,vault_id)
+        params[:customer_vault_id] = vault_id
+      end
+
+      def add_creditcard(post, creditcard,options)
+        if options[:store]
+          post[:customer_vault] = "add_customer"
+          post[:customer_vault_id] = options[:store] unless options[:store] == true
+        end
+        post[:ccnumber]  = creditcard.number
+        post[:cvv] = creditcard.verification_value if creditcard.verification_value?
+        post[:ccexp]  = expdate(creditcard)
+        post[:firstname] = creditcard.first_name
+        post[:lastname]  = creditcard.last_name
+      end
+
+      def add_check(post, check)
+        post[:payment] = 'check' # Set transaction to ACH
+        post[:checkname] = check.name # The name on the customer's Checking Account
+        post[:checkaba] = check.routing_number # The customer's bank routing number
+        post[:checkaccount] = check.account_number # The customer's account number
+        post[:account_holder_type] = check.account_holder_type # The customer's type of ACH account
+        post[:account_type] = check.account_type # The customer's type of ACH account
+      end
+
+      def parse(body)
+        results = {}
+        body.split(/&/).each do |pair|
+          key,val = pair.split(%r{=})
+          results[key] = val
+        end
+
+        results
+      end
+
+      def commit(action, money, parameters)
+        parameters[:amount]  = amount(money) if money
+
+        response = parse( ssl_post(self.live_url, post_data(action,parameters)) )
+
+        Response.new(response["response"] == "1", message_from(response), response,
+          :authorization => response["transactionid"],
+          :test => test?,
+          :cvv_result => response["cvvresponse"],
+          :avs_result => { :code => response["avsresponse"] }
+        )
+
+      end
+
+      def message_from(response)
+        case response["responsetext"]
+        when "SUCCESS","Approved"
+          "This transaction has been approved"
+        when "DECLINE"
+          "This transaction has been declined"
+        else
+          response["responsetext"]
+        end
+      end
+
+      def post_data(action, parameters = {})
+        post = {}
+        post[:username]      = @options[:login]
+        post[:password]   = @options[:password]
+        post[:type]       = action if action
+
+        request = post.merge(parameters).map {|key,value| "#{key}=#{CGI.escape(value.to_s)}"}.join("&")
+        request
+      end
+
+      def determine_funding_source(source)
+        case
+        when source.is_a?(String) then :vault
+        when CreditCard.card_companies.keys.include?(card_brand(source)) then :credit_card
+        when card_brand(source) == 'check' then :check
+        else raise ArgumentError, "Unsupported funding source provided"
+        end
+      end
+    end
+  end
+end
+

data/lib/active_merchant/billing/gateways/instapay.rb

@@ -0,0 +1,163 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class InstapayGateway < Gateway
+      self.live_url = 'https://trans.instapaygateway.com/cgi-bin/process.cgi'
+
+      # The countries the gateway supports merchants from as 2 digit ISO country codes
+      self.supported_countries = ['US']
+      self.money_format = :dollars
+      self.default_currency = 'USD'
+      # The card types supported by the payment gateway
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover]
+
+      # The homepage URL of the gateway
+      self.homepage_url = 'http://www.instapayllc.com'
+
+      # The name of the gateway
+      self.display_name = 'InstaPay'
+
+      SUCCESS         = "Accepted"
+      SUCCESS_MESSAGE = "The transaction has been approved"
+
+      def initialize(options = {})
+        requires!(options, :login)
+        super
+      end
+
+      def authorize(money, creditcard, options = {})
+        post = {}
+        post[:authonly] = 1
+        add_amount(post, money)
+        add_invoice(post, options)
+        add_creditcard(post, creditcard)
+        add_address(post, options)
+        add_customer_data(post, options)
+
+        commit('ns_quicksale_cc', post)
+      end
+
+      def purchase(money, creditcard, options = {})
+        post = {}
+        add_amount(post, money)
+        add_invoice(post, options)
+        add_creditcard(post, creditcard)
+        add_address(post, options)
+        add_customer_data(post, options)
+
+        commit('ns_quicksale_cc', post)
+      end
+
+      def capture(money, authorization, options = {})
+        post = {}
+        add_amount(post, money)
+        add_reference(post, authorization)
+        commit('ns_quicksale_cc', post)
+      end
+
+      private
+
+      def add_amount(post, money)
+        post[:amount] = amount(money)
+      end
+
+      def add_reference(post, reference)
+        post[:postonly] = reference
+      end
+
+      def add_customer_data(post, options)
+        post[:ci_email]       = options[:email]
+        post["ci_IP Address"] = options[:ip]
+      end
+
+      def add_address(post, options)
+        if address = options[:billing_address] || options[:address]
+          post[:ci_billaddr1]   = address[:address1]
+          post[:ci_billaddr2]   = address[:address2]
+          post[:ci_billcity]    = address[:city]
+          post[:ci_billstate]   = address[:state]
+          post[:ci_billzip]     = address[:zip]
+          post[:ci_billcountry] = address[:country]
+          post[:ci_phone]       = address[:phone]
+        end
+
+        if address = options[:shipping_address]
+          post[:ci_shipaddr1]   = address[:address1]
+          post[:ci_shipaddr2]   = address[:address2]
+          post[:ci_shipcity]    = address[:city]
+          post[:ci_shipstate]   = address[:state]
+          post[:ci_shipzip]     = address[:zip]
+          post[:ci_shipcountry] = address[:country]
+        end
+      end
+
+      def add_invoice(post, options)
+        post[:merchantordernumber] = options[:order_id]
+        post[:ci_memo]             = options[:description]
+        post[:pocustomerrefid]     = options[:invoice]
+      end
+
+      def add_creditcard(post, creditcard)
+        post[:ccnum]   = creditcard.number
+        post[:expmon]  = format(creditcard.month, :two_digits)
+        post[:cvv2]    = creditcard.verification_value if creditcard.verification_value?
+        post[:expyear] = creditcard.year
+        post[:ccname]  = creditcard.name
+      end
+
+      def parse(body)
+        results = {}
+        fields = body.split("\r\n")
+
+        response = fields[1].split('=')
+        response_data = response[1].split(':')
+
+        if response[0] == SUCCESS
+          results[:success] = true
+          results[:message] = SUCCESS_MESSAGE
+          results[:transaction_type] = response_data[0]
+          results[:authorization_code] = response_data[1]
+          results[:reference_number] = response_data[2]
+          results[:batch_number] = response_data[3]
+          results[:transaction_id] = response_data[4]
+          results[:avs_result] = response_data[5]
+          results[:authorize_net] = response_data[6]
+          results[:cvv_result] = response_data[7]
+        else
+          results[:success] = false
+          results[:result] = response_data[0]
+          results[:response_code] = response_data[1]
+          results[:message] = response_data[2]
+        end
+
+        fields[1..-1].each do |pair|
+          key, value = pair.split('=')
+          results[key] = value
+        end
+        results
+      end
+
+      def commit(action, parameters)
+        data = ssl_post self.live_url, post_data(action, parameters)
+        response = parse(data)
+
+        Response.new(response[:success] , response[:message], response,
+          :authorization => response[:transaction_id],
+          :avs_result => { :code => response[:avs_result] },
+          :cvv_result => response[:cvv_result]
+        )
+      end
+
+      def post_data(action, parameters = {})
+        post = {}
+        post[:acctid] = @options[:login]
+        if(@options[:password])
+          post[:merchantpin] = @options[:password]
+        end
+        post[:action] = action
+        request = post.merge(parameters).collect { |key, value| "#{key}=#{CGI.escape(value.to_s)}" }.join("&")
+        request
+      end
+    end
+  end
+end
+