johnreitano-activemerchant 1.5.2

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

@@ -0,0 +1,229 @@
+require 'rexml/document'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+
+    class EfsnetGateway < Gateway
+      self.supported_countries = ['US']
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover]
+      self.homepage_url = 'http://www.concordefsnet.com/'
+      self.display_name = 'Efsnet'
+     
+      TEST_URL = 'https://testefsnet.concordebiz.com/efsnet.dll'
+      LIVE_URL = 'https://efsnet.concordebiz.com/efsnet.dll'
+      
+      # login is your Store ID
+      # password is your Store Key
+      def initialize(options = {})
+        requires!(options, :login, :password)
+        @options = options
+        super      
+      end
+      
+      def test?
+        @options[:test] || super
+      end
+      
+      def authorize(money, creditcard, options = {})
+        request = build_credit_card_request(money, creditcard, options)
+        commit(:credit_card_authorize, request)
+      end
+
+      def purchase(money, creditcard, options = {})
+        request = build_credit_card_request(money, creditcard, options)
+        commit(:credit_card_charge, request)
+      end
+     
+      def capture(money, identification, options = {})
+        request = build_refund_or_settle_request(money, identification, options)
+        commit(:credit_card_settle, request)
+      end
+
+      def credit(money, identification_or_credit_card, options = {})
+        if identification_or_credit_card.is_a?(String)
+          # Perform authorization reversal
+          request = build_refund_or_settle_request(money, identification_or_credit_card, options)
+          commit(:credit_card_refund, request)
+        else
+          # Perform credit
+          request = build_credit_card_request(money, identification_or_credit_card, options)
+          commit(:credit_card_credit, request)
+        end
+      end
+
+      def void(identification, options = {})
+        requires!(options, :order_id)
+        original_transaction_id, original_transaction_amount = identification.split(";")
+        commit(:void_transaction, {:reference_number => format_reference_number(options[:order_id]), :transaction_ID => original_transaction_id})
+      end
+      
+      def voice_authorize(money, authorization_code, creditcard, options = {})
+        options[:authorization_number] = authorization_code
+        request = build_credit_card_request(money, creditcard, options)
+        commit(:credit_card_voice_authorize, request)
+      end
+      
+      def force(money, authorization_code, creditcard, options = {})
+        options[:authorization_number] = authorization_code
+        request = build_credit_card_request(money, creditcard, options)
+        commit(:credit_card_capture, request)
+      end
+      
+      def system_check
+        commit(:system_check, {})      
+      end
+
+      private
+
+      def build_refund_or_settle_request(money, identification, options = {})
+        original_transaction_id, original_transaction_amount = identification.split(";")
+        
+        requires!(options, :order_id)
+
+        post = {
+          :reference_number => format_reference_number(options[:order_id]),
+          :transaction_amount => amount(money),
+          :original_transaction_amount => original_transaction_amount,
+          :original_transaction_ID => original_transaction_id,
+          :client_ip_address => options[:ip]
+        }
+      end
+    
+      def build_credit_card_request(money, creditcard, options = {})
+        requires!(options, :order_id)
+
+        post = {
+          :reference_number => format_reference_number(options[:order_id]),
+          :authorization_number => options[:authorization_number],
+          :transaction_amount => amount(money),
+          :client_ip_address => options[:ip]
+          
+        }
+        add_creditcard(post,creditcard)
+        add_address(post,options)
+        post
+      end
+      
+      def format_reference_number(number)
+        number.to_s.slice(0,12)
+      end
+    
+      def add_address(post,options)
+        if address = options[:billing_address] || options[:address]
+          if address[:address2]
+            post[:billing_address]    = address[:address1].to_s << ' ' <<  address[:address2].to_s
+          else
+            post[:billing_address]    = address[:address1].to_s
+          end
+          post[:billing_city]         = address[:city].to_s
+          post[:billing_state]        = address[:state].blank?  ? 'n/a' : address[:state]
+          post[:billing_postal_code]  = address[:zip].to_s       
+          post[:billing_country]      = address[:country].to_s
+        end
+
+        if address = options[:shipping_address]
+          if address[:address2]
+            post[:shipping_address]   = address[:address1].to_s << ' ' <<  address[:address2].to_s
+          else
+            post[:shipping_address]   = address[:address1].to_s
+          end
+          post[:shipping_city]        = address[:city].to_s
+          post[:shipping_state]       = address[:state].blank?  ? 'n/a' : address[:state]
+          post[:shipping_postal_code] = address[:zip].to_s       
+          post[:shipping_country]     = address[:country].to_s
+        end
+      end
+
+      def add_creditcard(post, creditcard)      
+        post[:billing_name]  = creditcard.name if creditcard.name
+        post[:account_number]  = creditcard.number
+        post[:card_verification_value] = creditcard.verification_value if creditcard.verification_value?
+        post[:expiration_month]  = sprintf("%.2i", creditcard.month)
+        post[:expiration_year]  = sprintf("%.4i", creditcard.year)[-2..-1]
+      end
+
+  
+      def commit(action, parameters)  
+        response = parse(ssl_post(test? ? TEST_URL : LIVE_URL, post_data(action, parameters), 'Content-Type' => 'text/xml'))
+
+        Response.new(success?(response), message_from(response[:result_message]), response,
+          :test => test?,
+          :authorization => authorization_from(response, parameters),
+          :avs_result => { :code => response[:avs_response_code] },
+          :cvv_result => response[:cvv_response_code]
+        )
+      end
+      
+      def success?(response)
+        response[:response_code] == '0'
+      end
+      
+      def authorization_from(response, params)
+        [ response[:transaction_id], params[:transaction_amount] ].compact.join(';')
+      end
+                                               
+      def parse(xml)
+        response = {}
+
+        xml = REXML::Document.new(xml)          
+
+        xml.elements.each('//Reply//TransactionReply/*') do |node|
+
+          response[node.name.underscore.to_sym] = normalize(node.text)
+
+        end unless xml.root.nil?
+
+        response
+      end     
+
+      def post_data(action, parameters = {})
+        xml   = REXML::Document.new("<?xml version='1.0' encoding='UTF-8'?>")
+        root  = xml.add_element("Request")
+        root.attributes["StoreID"] = options[:login]
+        root.attributes["StoreKey"] = options[:password]
+        root.attributes["ApplicationID"] = 'ot 1.0'
+        transaction = root.add_element(action.to_s.camelize)
+
+        actions[action].each do |key|
+          transaction.add_element(key.to_s.camelize).text = parameters[key] unless parameters[key].blank?
+        end
+
+        xml.to_s
+      end
+    
+      def message_from(message)
+        return 'Unspecified error' if message.blank?
+        message.gsub(/[^\w]/, ' ').split.join(" ").capitalize
+      end
+
+      # Make a ruby type out of the response string
+      def normalize(field)
+        case field
+        when "true"   then true
+        when "false"  then false
+        when ""       then nil
+        when "null"   then nil
+        else field
+        end        
+      end         
+    
+      def actions
+        ACTIONS
+      end
+
+      CREDIT_CARD_FIELDS =  [:authorization_number, :client_ip_address, :billing_address, :billing_city, :billing_state, :billing_postal_code, :billing_country, :billing_name, :card_verification_value, :expiration_month, :expiration_year, :reference_number, :transaction_amount, :account_number ]
+
+      ACTIONS = {
+           :credit_card_authorize		=> CREDIT_CARD_FIELDS,
+           :credit_card_charge			=> CREDIT_CARD_FIELDS,
+           :credit_card_voice_authorize		=> CREDIT_CARD_FIELDS,
+           :credit_card_capture			=> CREDIT_CARD_FIELDS,
+           :credit_card_credit			=> CREDIT_CARD_FIELDS << :original_transaction_amount,
+           :credit_card_refund			=> [:reference_number, :transaction_amount, :original_transaction_amount, :original_transaction_ID, :client_ip_address],
+           :void_transaction			=> [:reference_number, :transaction_ID],
+           :credit_card_settle			=> [:reference_number, :transaction_amount, :original_transaction_amount, :original_transaction_ID, :client_ip_address],
+           :system_check			=> [:system_check],
+      }    
+    end
+  end
+end

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

@@ -0,0 +1,134 @@
+require File.dirname(__FILE__) + '/viaklix'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    # = Elavon Virtual Merchant Gateway
+    #
+    # == Example use:
+    #
+    #   gateway = ActiveMerchant::Billing::ElavonGateway.new(
+    #               :login     => "my_virtual_merchant_id",
+    #               :password  => "my_virtual_merchant_pin",
+    #               :user      => "my_virtual_merchant_user_id" # optional
+    #            )
+    #
+    #   # set up credit card obj as in main ActiveMerchant example
+    #   creditcard = ActiveMerchant::Billing::CreditCard.new(
+    #     :type       => 'visa',
+    #     :number     => '41111111111111111',
+    #     :month      => 10,
+    #     :year       => 2011,
+    #     :first_name => 'Bob',
+    #     :last_name  => 'Bobsen'
+    #   )
+    #
+    #   # run request
+    #   response = gateway.purchase(1000, creditcard) # authorize and capture 10 USD
+    #
+    #   puts response.success?      # Check whether the transaction was successful
+    #   puts response.message       # Retrieve the message returned by Elavon
+    #   puts response.authorization # Retrieve the unique transaction ID returned by Elavon
+    #
+    class ElavonGateway < ViaklixGateway
+      self.test_url = self.live_url = 'https://www.myvirtualmerchant.com/VirtualMerchant/process.do'
+
+      self.display_name = 'Elavon MyVirtualMerchant'
+      self.supported_countries = ['US', 'CA']
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover]
+      self.homepage_url = 'http://www.elavon.com/'
+
+      self.delimiter = "\n"
+      self.actions = {
+        :purchase => 'CCSALE',
+        :credit => 'CCCREDIT',
+        :authorize => 'CCAUTHONLY',
+        :capture => 'CCFORCE'
+      }
+      
+      # Authorize a credit card for a given amount.
+      # 
+      # ==== Parameters
+      # * <tt>money</tt> - The amount to be authorized as an Integer value in cents.
+      # * <tt>credit_card</tt> - The CreditCard details for the transaction.
+      # * <tt>options</tt>
+      #   * <tt>:billing_address</tt> - The billing address for the cardholder.      
+      def authorize(money, creditcard, options = {})
+        form = {}
+        add_invoice(form, options)
+        add_creditcard(form, creditcard)        
+        add_address(form, options)   
+        add_customer_data(form, options)
+        commit(:authorize, money, form)
+      end
+      
+      # Capture authorized funds from a credit card.
+      # 
+      # ==== Parameters
+      # * <tt>money</tt> - The amount to be captured as an Integer value in cents.
+      # * <tt>authorization</tt> - The approval code returned from the initial authorization.
+      # * <tt>options</tt>
+      #   * <tt>:credit_card</tt> - The CreditCard details from the initial transaction (required).
+      def capture(money, authorization, options = {})
+        requires!(options, :credit_card)
+        
+        form = {}
+        add_reference(form, authorization)
+        add_invoice(form, options)
+        add_creditcard(form, options[:credit_card])
+        add_customer_data(form, options)
+        commit(:capture, money, form)
+      end
+      
+      private
+      def add_reference(form, authorization)
+        form[:approval_code] = authorization
+      end
+      
+      def authorization_from(response)
+        response['approval_code']
+      end
+      
+      def add_verification_value(form, creditcard)
+        form[:cvv2cvc2] = creditcard.verification_value 
+        form[:cvv2cvc2_indicator] = '1'
+      end
+
+      def add_address(form,options)
+        billing_address = options[:billing_address] || options[:address] 
+        
+        if billing_address
+          form[:avs_address]    = billing_address[:address1].to_s.slice(0, 30)
+          form[:address2]       = billing_address[:address2].to_s.slice(0, 30)
+          form[:avs_zip]        = billing_address[:zip].to_s.slice(0, 10)
+          form[:city]           = billing_address[:city].to_s.slice(0, 30)
+          form[:state]          = billing_address[:state].to_s.slice(0, 10)
+          form[:company]        = billing_address[:company].to_s.slice(0, 50)
+          form[:phone]          = billing_address[:phone].to_s.slice(0, 20)
+          form[:country]        = billing_address[:country].to_s.slice(0, 50)
+        end
+                
+        if shipping_address = options[:shipping_address]
+          first_name, last_name = parse_first_and_last_name(shipping_address[:name])
+          form[:ship_to_first_name]     = first_name.to_s.slice(0, 20)
+          form[:ship_to_last_name]      = last_name.to_s.slice(0, 30)
+          form[:ship_to_address1]       = shipping_address[:address1].to_s.slice(0, 30)
+          form[:ship_to_address2]       = shipping_address[:address2].to_s.slice(0, 30)
+          form[:ship_to_city]           = shipping_address[:city].to_s.slice(0, 30)
+          form[:ship_to_state]          = shipping_address[:state].to_s.slice(0, 10)
+          form[:ship_to_company]        = shipping_address[:company].to_s.slice(0, 50)
+          form[:ship_to_country]        = shipping_address[:country].to_s.slice(0, 50)
+          form[:ship_to_zip]            = shipping_address[:zip].to_s.slice(0, 10)
+        end
+      end
+      
+      def message_from(response)
+        success?(response) ? response['result_message'] : response['errorMessage']
+      end
+      
+      def success?(response)
+        !response.has_key?('errorMessage')
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,277 @@
+require 'rexml/document'
+
+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 US becomes 1000.
+    #
+    #   tendollar = 1000
+    #
+    # Next, create a credit card object using a TC approved test card.
+    #
+    #   creditcard = ActiveMerchant::Billing::CreditCard.new(
+    #	    :number => '4111111111111111',
+    #	    :month => 8,
+    #	    :year => 2006,
+    #	    :first_name => 'Longbob',
+    #     :last_name => 'Longsen'
+    #   )
+    #   options = {
+    #     :order_id => '1230123',
+    #     :email => 'bob@testbob.com',
+    #     :address => { :address1 => '47 Bobway',
+    #                   :city => 'Bobville', 
+    #                   :state => 'WA',
+    #                   :country => 'Australia',
+    #                   :zip => '2000'
+    #                 }
+    #     :description => 'purchased items'
+    #   }
+    #
+    # To finish setting up, create the active_merchant object you will be using, with the eWay gateway. If you have a
+    # functional eWay account, replace :login with your account info. 
+    #
+    #   gateway = ActiveMerchant::Billing::Base.gateway(:eway).new(:login => '87654321')
+    #
+    # Now we are ready to process our transaction
+    #
+    #   response = gateway.purchase(tendollar, creditcard, options)
+    #
+    # Sending a transaction to TrustCommerce with active_merchant returns a Response object, which consistently allows you to:
+    #
+    # 1) Check whether the transaction was successful
+    #
+    #   response.success?
+    #
+    # 2) Retrieve any message returned by eWay, either a "transaction was successful" note or an explanation of why the
+    # transaction was rejected.
+    #
+    #   response.message
+    #
+    # 3) Retrieve and store the unique transaction ID returned by eWway, for use in referencing the transaction in the future.
+    #
+    #   response.authorization
+    #
+    # This should be enough to get you started with eWay and active_merchant. For further information, review the methods
+    # below and the rest of active_merchant's documentation.
+
+    class EwayGateway < Gateway 
+      TEST_URL     = 'https://www.eway.com.au/gateway/xmltest/testpage.asp'
+      LIVE_URL     = 'https://www.eway.com.au/gateway/xmlpayment.asp'
+      
+      TEST_CVN_URL = 'https://www.eway.com.au/gateway_cvn/xmltest/testpage.asp'
+      LIVE_CVN_URL = 'https://www.eway.com.au/gateway_cvn/xmlpayment.asp'
+      
+      MESSAGES = {
+        "00" => "Transaction Approved",
+        "01" => "Refer to Issuer",
+        "02" => "Refer to Issuer, special",	
+        "03" => "No Merchant",
+        "04" => "Pick Up Card",	
+        "05" => "Do Not Honour",	
+        "06" => "Error",
+        "07" => "Pick Up Card, Special",	
+        "08" => "Honour With Identification",	
+        "09" => "Request In Progress",
+        "10" => "Approved For Partial Amount",	
+        "11" => "Approved, VIP",	
+        "12" => "Invalid Transaction",	
+        "13" => "Invalid Amount",
+        "14" => "Invalid Card Number",	
+        "15" => "No Issuer",	
+        "16" => "Approved, Update Track 3",	
+        "19" => "Re-enter Last Transaction",	
+        "21" => "No Action Taken",	
+        "22" => "Suspected Malfunction",	
+        "23" => "Unacceptable Transaction Fee",	
+        "25" => "Unable to Locate Record On File",	
+        "30" => "Format Error",	
+        "31" => "Bank Not Supported By Switch",	
+        "33" => "Expired Card, Capture",	
+        "34" => "Suspected Fraud, Retain Card",	
+        "35" => "Card Acceptor, Contact Acquirer, Retain Card",	
+        "36" => "Restricted Card, Retain Card",	
+        "37" => "Contact Acquirer Security Department, Retain Card",	
+        "38" => "PIN Tries Exceeded, Capture",	
+        "39" => "No Credit Account",	
+        "40" => "Function Not Supported",	
+        "41" => "Lost Card",	
+        "42" => "No Universal Account",	
+        "43" => "Stolen Card",	
+        "44" => "No Investment Account",	
+        "51" => "Insufficient Funds",	
+        "52" => "No Cheque Account",	
+        "53" => "No Savings Account",	
+        "54" => "Expired Card",	
+        "55" => "Incorrect PIN",	
+        "56" => "No Card Record",	
+        "57" => "Function Not Permitted to Cardholder",	
+        "58" => "Function Not Permitted to Terminal",	
+        "59" => "Suspected Fraud",	
+        "60" => "Acceptor Contact Acquirer",	
+        "61" => "Exceeds Withdrawal Limit",	
+        "62" => "Restricted Card",	
+        "63" => "Security Violation",	
+        "64" => "Original Amount Incorrect",	
+        "66" => "Acceptor Contact Acquirer, Security",	
+        "67" => "Capture Card",	
+        "75" => "PIN Tries Exceeded",	
+        "82" => "CVV Validation Error",	
+        "90" => "Cutoff In Progress",	
+        "91" => "Card Issuer Unavailable",	
+        "92" => "Unable To Route Transaction",	
+        "93" => "Cannot Complete, Violation Of The Law",	
+        "94" => "Duplicate Transaction",	
+        "96" => "System Error"
+      }
+      
+	    self.money_format = :cents
+      self.supported_countries = ['AU']
+      self.supported_cardtypes = [:visa, :master, :american_express]
+      self.homepage_url = 'http://www.eway.com.au/'
+      self.display_name = 'eWAY'
+	    
+    	def initialize(options = {})
+        requires!(options, :login)
+        @options = options
+        super
+    	end
+
+      # ewayCustomerEmail, ewayCustomerAddress, ewayCustomerPostcode
+      def purchase(money, creditcard, options = {})
+        requires!(options, :order_id)
+
+        post = {}
+        add_creditcard(post, creditcard)
+        add_address(post, options)  
+        add_customer_data(post, options)
+        add_invoice_data(post, options)
+        # The request fails if all of the fields aren't present
+        add_optional_data(post)
+    
+        commit(money, post)
+      end
+      
+      def test?
+        @options[:test] || super
+      end
+      
+      private                       
+      def add_creditcard(post, creditcard)
+        post[:CardNumber]  = creditcard.number
+        post[:CardExpiryMonth]  = sprintf("%.2i", creditcard.month)
+        post[:CardExpiryYear] = sprintf("%.4i", creditcard.year)[-2..-1]
+        post[:CustomerFirstName] = creditcard.first_name
+        post[:CustomerLastName]  = creditcard.last_name
+        post[:CardHoldersName] = creditcard.name
+              
+        post[:CVN] = creditcard.verification_value if creditcard.verification_value?
+      end 
+
+      def add_address(post, options)
+        if address = options[:billing_address] || options[:address]
+          post[:CustomerAddress]    = [ address[:address1], address[:address2], address[:city], address[:state], address[:country] ].compact.join(', ')
+          post[:CustomerPostcode]   = address[:zip]
+        end
+      end
+
+      def add_customer_data(post, options)
+        post[:CustomerEmail] = options[:email]
+      end
+      
+      def add_invoice_data(post, options)
+        post[:CustomerInvoiceRef] = options[:order_id]
+        post[:CustomerInvoiceDescription] = options[:description]
+      end
+
+      def add_optional_data(post)
+        post[:TrxnNumber] = nil
+        post[:Option1] = nil
+        post[:Option2] = nil
+        post[:Option3] = nil     
+      end
+
+      def commit(money, parameters)       
+        parameters[:TotalAmount] = amount(money)
+
+        response = parse( ssl_post(gateway_url(parameters[:CVN], test?), post_data(parameters)) )
+
+        Response.new(success?(response), message_from(response[:ewaytrxnerror]), response,
+          :authorization => response[:ewayauthcode],
+          :test => /\(Test( CVN)? Gateway\)/ === response[:ewaytrxnerror]
+        )      
+      end
+      
+      def success?(response)
+        response[:ewaytrxnstatus] == "True"
+      end
+                                             
+      # Parse eway response xml into a convinient hash
+      def parse(xml)
+        #  "<?xml version=\"1.0\"?>".
+        #  <ewayResponse>
+        #  <ewayTrxnError></ewayTrxnError>
+        #  <ewayTrxnStatus>True</ewayTrxnStatus>
+        #  <ewayTrxnNumber>10002</ewayTrxnNumber>
+        #  <ewayTrxnOption1></ewayTrxnOption1>
+        #  <ewayTrxnOption2></ewayTrxnOption2>
+        #  <ewayTrxnOption3></ewayTrxnOption3>
+        #  <ewayReturnAmount>10</ewayReturnAmount>
+        #  <ewayAuthCode>123456</ewayAuthCode>
+        #  <ewayTrxnReference>987654321</ewayTrxnReference>
+        #  </ewayResponse>     
+
+        response = {}
+        xml = REXML::Document.new(xml)          
+        xml.elements.each('//ewayResponse/*') do |node|
+
+          response[node.name.downcase.to_sym] = normalize(node.text)
+
+        end unless xml.root.nil?
+
+        response
+      end   
+
+      def post_data(parameters = {})
+        parameters[:CustomerID] = @options[:login]
+        
+        xml   = REXML::Document.new
+        root  = xml.add_element("ewaygateway")
+        
+        parameters.each do |key, value|
+          root.add_element("eway#{key}").text = value
+        end    
+        xml.to_s
+      end
+    
+      def message_from(message)
+        return '' if message.blank?
+        MESSAGES[message[0,2]] || message
+      end
+
+      # Make a ruby type out of the response string
+      def normalize(field)
+        case field
+        when "true"   then true
+        when "false"  then false
+        when ""       then nil
+        when "null"   then nil
+        else field
+        end        
+      end
+      
+      def gateway_url(cvn, test)
+        if cvn
+          test ? TEST_CVN_URL : LIVE_CVN_URL
+        else
+          test ? TEST_URL : LIVE_URL
+        end
+      end
+      
+    end
+  end
+end