jelaniharris-activemerchant 1.24.1

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

@@ -0,0 +1,202 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+
+    class UsaEpayTransactionGateway < Gateway
+    	URL = 'https://www.usaepay.com/gate.php'
+
+      self.supported_cardtypes = [:visa, :master, :american_express]
+      self.supported_countries = ['US']
+      self.homepage_url = 'http://www.usaepay.com/'
+      self.display_name = 'USA ePay'
+
+      TRANSACTIONS = {
+        :authorization => 'authonly',
+        :purchase => 'sale',
+        :capture => 'capture',
+        :refund => 'refund',
+        :void => 'void'
+      }
+
+      def initialize(options = {})
+        requires!(options, :login)
+        @options = options
+        super
+      end
+
+      def authorize(money, credit_card, options = {})
+        post = {}
+
+        add_amount(post, money)
+        add_invoice(post, options)
+        add_credit_card(post, credit_card)
+        add_address(post, credit_card, options)
+        add_customer_data(post, options)
+
+        commit(:authorization, post)
+      end
+
+      def purchase(money, credit_card, options = {})
+        post = {}
+
+        add_amount(post, money)
+        add_invoice(post, options)
+        add_credit_card(post, credit_card)
+        add_address(post, credit_card, options)
+        add_customer_data(post, options)
+
+        commit(:purchase, post)
+      end
+
+      def capture(money, authorization, options = {})
+        post = { :refNum => authorization }
+
+        add_amount(post, money)
+        commit(:capture, post)
+      end
+
+      def refund(money, authorization, options = {})
+        post = { :refNum => authorization }
+
+        add_amount(post, money)
+        commit(:refund, post)
+      end
+
+      def void(authorization, options = {})
+        post = { :refNum => authorization }
+        commit(:void, post)
+      end
+
+      private
+
+      def add_amount(post, money)
+        post[:amount] = amount(money)
+      end
+
+      def expdate(credit_card)
+        year  = format(credit_card.year, :two_digits)
+        month = format(credit_card.month, :two_digits)
+
+        "#{month}#{year}"
+      end
+
+      def add_customer_data(post, options)
+        address = options[:billing_address] || options[:address] || {}
+        post[:street] = address[:address1]
+        post[:zip] = address[:zip]
+
+        if options.has_key? :email
+          post[:custemail] = options[:email]
+          post[:custreceipt] = 'No'
+        end
+
+        if options.has_key? :customer
+          post[:custid] = options[:customer]
+        end
+
+        if options.has_key? :ip
+          post[:ip] = options[:ip]
+        end
+      end
+
+      def add_address(post, credit_card, options)
+        billing_address = options[:billing_address] || options[:address]
+
+        add_address_for_type(:billing, post, credit_card, billing_address) if billing_address
+        add_address_for_type(:shipping, post, credit_card, options[:shipping_address]) if options[:shipping_address]
+      end
+
+      def add_address_for_type(type, post, credit_card, address)
+        prefix = address_key_prefix(type)
+
+        post[address_key(prefix, 'fname')] = credit_card.first_name
+        post[address_key(prefix, 'lname')] = credit_card.last_name
+        post[address_key(prefix, 'company')] = address[:company] unless address[:company].blank?
+        post[address_key(prefix, 'street')] = address[:address1] unless address[:address1].blank?
+        post[address_key(prefix, 'street2')] = address[:address2] unless address[:address2].blank?
+        post[address_key(prefix, 'city')] = address[:city] unless address[:city].blank?
+        post[address_key(prefix, 'state')] = address[:state] unless address[:state].blank?
+        post[address_key(prefix, 'zip')] = address[:zip] unless address[:zip].blank?
+        post[address_key(prefix, 'country')] = address[:country] unless address[:country].blank?
+        post[address_key(prefix, 'phone')] = address[:phone] unless address[:phone].blank?
+      end
+
+      def address_key_prefix(type)
+        case type
+        when :shipping then 'ship'
+        when :billing then 'bill'
+        end
+      end
+
+      def address_key(prefix, key)
+        "#{prefix}#{key}".to_sym
+      end
+
+      def add_invoice(post, options)
+        post[:invoice] = options[:order_id]
+      end
+
+      def add_credit_card(post, credit_card)
+        post[:card]  = credit_card.number
+        post[:cvv2] = credit_card.verification_value if credit_card.verification_value?
+        post[:expir]  = expdate(credit_card)
+        post[:name] = credit_card.name
+      end
+
+      def parse(body)
+        fields = {}
+        for line in body.split('&')
+          key, value = *line.scan( %r{^(\w+)\=(.*)$} ).flatten
+          fields[key] = CGI.unescape(value.to_s)
+        end
+
+        {
+          :status => fields['UMstatus'],
+          :auth_code => fields['UMauthCode'],
+          :ref_num => fields['UMrefNum'],
+          :batch => fields['UMbatch'],
+          :avs_result => fields['UMavsResult'],
+          :avs_result_code => fields['UMavsResultCode'],
+          :cvv2_result => fields['UMcvv2Result'],
+          :cvv2_result_code => fields['UMcvv2ResultCode'],
+          :vpas_result_code => fields['UMvpasResultCode'],
+          :result => fields['UMresult'],
+          :error => fields['UMerror'],
+          :error_code => fields['UMerrorcode'],
+          :acs_url => fields['UMacsurl'],
+          :payload => fields['UMpayload']
+        }.delete_if{|k, v| v.nil?}
+      end
+
+
+      def commit(action, parameters)
+        response = parse( ssl_post(URL, post_data(action, parameters)) )
+
+        Response.new(response[:status] == 'Approved', message_from(response), response,
+          :test => @options[:test] || test?,
+          :authorization => response[:ref_num],
+          :cvv_result => response[:cvv2_result_code],
+          :avs_result => { :code => response[:avs_result_code] }
+        )
+      end
+
+      def message_from(response)
+        if response[:status] == "Approved"
+          return 'Success'
+        else
+          return 'Unspecified error' if response[:error].blank?
+          return response[:error]
+        end
+      end
+
+      def post_data(action, parameters = {})
+        parameters[:command]  = TRANSACTIONS[action]
+        parameters[:key] = @options[:login]
+        parameters[:software] = 'Active Merchant'
+        parameters[:testmode] = @options[:test] ? 1 : 0
+
+        parameters.collect { |key, value| "UM#{key}=#{CGI.escape(value.to_s)}" }.join("&")
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,233 @@
+require 'rexml/document'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class VerifiGateway < Gateway 
+      class VerifiPostData < PostData
+        # Fields that will be sent even if they are blank
+        self.required_fields = [ :amount, :type, :ccnumber, :ccexp, :firstname, :lastname,
+          :company, :address1, :address2, :city, :state, :zip, :country, :phone ]   
+      end
+
+      URL = 'https://secure.verifi.com/gw/api/transact.php'
+            
+      RESPONSE_CODE_MESSAGES = {
+        "100" => "Transaction was Approved", 
+        "200" => "Transaction was Declined by Processor", 
+        "201" => "Do Not Honor", 
+        "202" => "Insufficient Funds", 
+        "203" => "Over Limit", 
+        "204" => "Transaction not allowed", 
+        "220" => "Incorrect payment Data", 
+        "221" => "No Such Card Issuer", 
+        "222" => "No Card Number on file with Issuer", 
+        "223" => "Expired Card", 
+        "224" => "Invalid Expiration Date", 
+        "225" => "Invalid Card Security Code", 
+        "240" => "Call Issuer for Further Information", 
+        "250" => "Pick Up Card", 
+        "251" => "Lost Card", 
+        "252" => "Stolen Card", 
+        "253" => "Fraudulent Card", 
+        "260" => "Declined With further Instructions Available (see response text)", 
+        "261" => "Declined - Stop All Recurring Payments", 
+        "262" => "Declined - Stop this Recurring Program", 
+        "263" => "Declined - Update Cardholder Data Available", 
+        "264" => "Declined - Retry in a few days", 
+        "300" => "Transaction was Rejected by Gateway", 
+        "400" => "Transaction Error Returned by Processor", 
+        "410" => "Invalid Merchant Configuration", 
+        "411" => "Merchant Account is Inactive", 
+        "420" => "Communication Error", 
+        "421" => "Communication Error with Issuer", 
+        "430" => "Duplicate Transaction at Processor", 
+        "440" => "Processor Format Error", 
+        "441" => "Invalid Transaction Information", 
+        "460" => "Processor Feature Not Available", 
+        "461" => "Unsupported Card Type"
+      }
+      
+      SUCCESS = 1
+      
+      TRANSACTIONS = {
+        :authorization => 'auth',
+        :purchase => 'sale',
+        :capture => 'capture',
+        :void => 'void',
+        :credit => 'credit',
+        :refund => 'refund'
+      }
+      
+      self.supported_countries = ['US']
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover]
+      self.homepage_url = 'http://www.verifi.com/'
+      self.display_name = 'Verifi'
+
+      def initialize(options = {})
+        requires!(options, :login, :password)
+        @options = options
+        super
+      end
+
+      def purchase(money, credit_card, options = {})
+        sale_authorization_or_credit_template(:purchase, money, credit_card, options)
+      end
+
+      def authorize(money, credit_card, options = {})
+        sale_authorization_or_credit_template(:authorization, money, credit_card, options)
+      end
+                       
+      def capture(money, authorization, options = {})
+        capture_void_or_refund_template(:capture, money, authorization, options)
+      end
+      
+      def void(authorization, options = {})
+        capture_void_or_refund_template(:void, 0, authorization, options)
+      end
+      
+      def credit(money, credit_card_or_authorization, options = {})
+        if credit_card_or_authorization.is_a?(String)
+          deprecated CREDIT_DEPRECATION_MESSAGE
+          refund(money, credit_card_or_authorization, options)
+        else
+          sale_authorization_or_credit_template(:credit, money, credit_card_or_authorization, options)
+        end
+      end
+
+      def refund(money, reference, options = {})
+        capture_void_or_refund_template(:refund, money, reference, options)
+      end
+
+      private  
+             
+      def sale_authorization_or_credit_template(trx_type, money, credit_card, options = {})
+        post = VerifiPostData.new
+        add_security_key_data(post, options, money)
+        add_credit_card(post, credit_card)
+        add_addresses(post, options)
+        add_customer_data(post, options)
+        add_invoice_data(post, options)
+        add_optional_data(post, options)
+        commit(trx_type, money, post)  
+      end
+
+      def capture_void_or_refund_template(trx_type, money, authorization, options)
+        post = VerifiPostData.new
+        post[:transactionid] = authorization
+        
+        commit(trx_type, money, post)
+      end
+                    
+      def add_credit_card(post, credit_card)
+        post[:ccnumber]  = credit_card.number
+        post[:ccexp]     = expdate(credit_card)
+        post[:firstname] = credit_card.first_name
+        post[:lastname]  = credit_card.last_name      
+        post[:cvv]       = credit_card.verification_value
+      end      
+                 
+      def expdate(credit_card)
+        year  = sprintf("%.4i", credit_card.year)
+        month = sprintf("%.2i", credit_card.month)
+
+        "#{month}#{year[-2..-1]}"
+      end
+
+      def add_addresses(post, options)
+        if billing_address = options[:billing_address] || options[:address]
+          post[:company]    = billing_address[:company]
+          post[:address1]   = billing_address[:address1]
+          post[:address2]   = billing_address[:address2]
+          post[:city]       = billing_address[:city]                           
+          post[:state]      = billing_address[:state]
+          post[:zip]        = billing_address[:zip]                               
+          post[:country]    = billing_address[:country]
+          post[:phone]      = billing_address[:phone]
+          post[:fax]        = billing_address[:fax]             
+        end
+        
+        if shipping_address = options[:shipping_address]
+          post[:shipping_firstname] = shipping_address[:first_name]
+          post[:shipping_lastname]  = shipping_address[:last_name]  
+          post[:shipping_company]   = shipping_address[:company]    
+          post[:shipping_address1]  = shipping_address[:address1]   
+          post[:shipping_address2]  = shipping_address[:address2]   
+          post[:shipping_city]      = shipping_address[:city]       
+          post[:shipping_state]     = shipping_address[:state]      
+          post[:shipping_zip]       = shipping_address[:zip]        
+          post[:shipping_country]   = shipping_address[:country]    
+          post[:shipping_email]     = shipping_address[:email]      
+        end        
+      end
+             
+      def add_customer_data(post, options)
+        post[:email]     = options[:email]
+        post[:ipaddress] = options[:ip]
+      end
+      
+      def add_invoice_data(post, options)
+        post[:orderid]            = options[:order_id]
+        post[:ponumber]           = options[:invoice]
+        post[:orderdescription]   = options[:description]
+        post[:tax]                = options[:tax]
+        post[:shipping]           = options[:shipping]
+      end
+      
+      def add_optional_data(post, options)
+        post[:billing_method]     = options[:billing_method]    
+        post[:website]            = options[:website]   
+        post[:descriptor]         = options[:descriptor]         
+        post[:descriptor_phone]   = options[:descriptor_phone]   
+        post[:cardholder_auth]    = options[:cardholder_auth]    
+        post[:cavv]               = options[:cavv]               
+        post[:xid]                = options[:xid]                
+        post[:customer_receipt]   = options[:customer_receipt]
+      end
+                       
+      def add_security_key_data(post, options, money)
+        # MD5(username|password|orderid|amount|time)
+        now = Time.now.to_i.to_s
+        md5 = Digest::MD5.new
+        md5 << @options[:login].to_s + "|"
+        md5 << @options[:password].to_s + "|"
+        md5 << options[:order_id].to_s + "|"
+        md5 << amount(money).to_s + "|"
+        md5 << now
+        post[:key]  = md5.hexdigest
+        post[:time] = now
+      end                  
+                                                    
+      def commit(trx_type, money, post)
+        post[:amount] = amount(money)
+        
+        response = parse( ssl_post(URL, post_data(trx_type, post)) )
+                         
+        Response.new(response[:response].to_i == SUCCESS, message_from(response), response,
+          :test => test?,
+          :authorization => response[:transactionid],
+          :avs_result => { :code => response[:avsresponse] },
+          :cvv_result => response[:cvvresponse]
+        )
+      end
+      
+      def message_from(response)
+        response[:response_code_message] ? response[:response_code_message] : ""
+      end
+                                                      
+      def parse(body)
+        results = {}
+        CGI.parse(body).each { |key, value| results[key.intern] = value[0] }
+        results[:response_code_message] = RESPONSE_CODE_MESSAGES[results[:response_code]] if results[:response_code]
+        results
+      end   
+      
+      def post_data(trx_type, post)
+        post[:username]   = @options[:login]  
+        post[:password]   = @options[:password]
+        post[:type]       = TRANSACTIONS[trx_type]
+        
+        post.to_s
+      end
+    end 
+  end
+end

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

@@ -0,0 +1,194 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class ViaklixGateway < Gateway
+      class_attribute :test_url, :live_url, :delimiter, :actions
+
+      self.test_url = 'https://demo.viaklix.com/process.asp'
+      self.live_url = 'https://www.viaklix.com/process.asp'
+      self.delimiter = "\r\n"
+      
+      self.actions = {
+        :purchase => 'SALE',
+        :credit => 'CREDIT'
+      }
+      
+      APPROVED = '0'
+      
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover]
+      self.supported_countries = ['US']
+      self.display_name = 'ViaKLIX'
+      self.homepage_url = 'http://viaklix.com'
+      
+      # Initialize the Gateway
+      #
+      # The gateway requires that a valid login and password be passed
+      # in the +options+ hash.
+      # 
+      # ==== Options
+      #
+      # * <tt>:login</tt> -- Merchant ID
+      # * <tt>:password</tt> -- PIN
+      # * <tt>:user</tt> -- Specify a subuser of the account (optional)
+      # * <tt>:test => +true+ or +false+</tt> -- Force test transactions
+      def initialize(options = {})
+        requires!(options, :login, :password)
+        @options = options
+        super
+      end
+      
+      # Make a purchase  
+      def purchase(money, creditcard, options = {})
+        form = {}
+        add_invoice(form, options)
+        add_creditcard(form, creditcard)        
+        add_address(form, options)   
+        add_customer_data(form, options)
+        add_test_mode(form, options)
+        commit(:purchase, money, form)
+      end
+      
+      # Make a credit to a card (Void can only be done from the virtual terminal)
+      # Viaklix does not support credits by reference. You must pass in the credit card
+      def credit(money, creditcard, options = {})
+        if creditcard.is_a?(String)
+          raise ArgumentError, "Reference credits are not supported. Please supply the original credit card"
+        end
+        
+        form = {}
+        add_invoice(form, options)
+        add_creditcard(form, creditcard)        
+        add_address(form, options)   
+        add_customer_data(form, options)
+        add_test_mode(form, options)
+        commit(:credit, money, form)
+      end
+      
+      private
+      def add_test_mode(form, options)
+        form[:test_mode] = 'TRUE' if options[:test_mode]
+      end
+      
+      def add_customer_data(form, options)
+        form[:email] = options[:email].to_s.slice(0, 100) unless options[:email].blank?
+        form[:customer_code] = options[:customer].to_s.slice(0, 10) unless options[:customer].blank?
+      end
+      
+      def add_invoice(form,options)
+        form[:invoice_number] = (options[:order_id] || options[:invoice]).to_s.slice(0, 10)
+        form[:description] = options[:description].to_s.slice(0, 255)
+      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_address]        = shipping_address[:address1].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 parse_first_and_last_name(value)
+        name = value.to_s.split(' ')
+        
+        last_name = name.pop || ''
+        first_name = name.join(' ')
+        [ first_name, last_name ] 
+      end
+      
+      def add_creditcard(form, creditcard)
+        form[:card_number] = creditcard.number
+        form[:exp_date] = expdate(creditcard)
+        
+        if creditcard.verification_value?
+          add_verification_value(form, creditcard)
+        end
+        
+        form[:first_name] = creditcard.first_name.to_s.slice(0, 20)
+        form[:last_name] = creditcard.last_name.to_s.slice(0, 30)
+      end
+      
+      def add_verification_value(form, creditcard)
+        form[:cvv2cvc2] = creditcard.verification_value 
+        form[:cvv2] = 'present'
+      end
+      
+      def preamble
+        result = {
+          'merchant_id'   => @options[:login],
+          'pin'           => @options[:password],
+          'show_form'     => 'false',
+          'result_format' => 'ASCII'          
+        }
+        
+        result['user_id'] = @options[:user] unless @options[:user].blank?
+        result
+      end
+      
+      def test?
+        @options[:test] || super
+      end
+      
+      def commit(action, money, parameters)
+        parameters[:amount] = amount(money)
+        parameters[:transaction_type] = self.actions[action]
+            
+        response = parse( ssl_post(test? ? self.test_url : self.live_url, post_data(parameters)) )
+
+        Response.new(response['result'] == APPROVED, message_from(response), response, 
+          :test => @options[:test] || test?, 
+          :authorization => authorization_from(response),
+          :avs_result => { :code => response['avs_response'] },
+          :cvv_result => response['cvv2_response']
+        )
+      end
+      
+      def authorization_from(response)
+        response['txn_id']
+      end
+      
+      def message_from(response)
+        response['result_message']
+      end
+      
+      def post_data(parameters)
+        result = preamble
+        result.merge!(parameters)        
+        result.collect { |key, value| "ssl_#{key}=#{CGI.escape(value.to_s)}" }.join("&")
+      end
+      
+      def expdate(creditcard)
+        year  = sprintf("%.4i", creditcard.year)
+        month = sprintf("%.2i", creditcard.month)
+        "#{month}#{year[2..3]}"
+      end
+      
+      # Parse the response message
+      def parse(msg)
+        resp = {}
+        msg.split(self.delimiter).collect{|li|
+            key, value = li.split("=")
+            resp[key.strip.gsub(/^ssl_/, '')] = value.to_s.strip
+          }
+        resp
+      end
+    end
+  end
+end