aktivemerchant 2.0.0

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

@@ -0,0 +1,254 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+
+    class UsaEpayTransactionGateway < Gateway
+      self.live_url = 'https://www.usaepay.com/gate'
+      self.test_url = 'https://sandbox.usaepay.com/gate'
+
+      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  => 'cc:authonly',
+        :purchase       => 'cc:sale',
+        :capture        => 'cc:capture',
+        :refund         => 'cc:refund',
+        :void           => 'cc:void'
+      }
+
+      STANDARD_ERROR_CODE_MAPPING = {
+        '00011' => STANDARD_ERROR_CODE[:incorrect_number],
+        '00012' => STANDARD_ERROR_CODE[:incorrect_number],
+        '00013' => STANDARD_ERROR_CODE[:incorrect_number],
+        '00014' => STANDARD_ERROR_CODE[:invalid_number],
+        '00015' => STANDARD_ERROR_CODE[:invalid_expiry_date],
+        '00016' => STANDARD_ERROR_CODE[:invalid_expiry_date],
+        '00017' => STANDARD_ERROR_CODE[:expired_card],
+        '10116' => STANDARD_ERROR_CODE[:incorrect_cvc],
+        '10107' => STANDARD_ERROR_CODE[:incorrect_zip],
+        '10109' => STANDARD_ERROR_CODE[:incorrect_address],
+        '10110' => STANDARD_ERROR_CODE[:incorrect_address],
+        '10111' => STANDARD_ERROR_CODE[:incorrect_address],
+        '10127' => STANDARD_ERROR_CODE[:card_declined],
+        '10128' => STANDARD_ERROR_CODE[:processing_error],
+        '10132' => STANDARD_ERROR_CODE[:processing_error],
+        '00043' => STANDARD_ERROR_CODE[:call_issuer]
+      }
+
+      def initialize(options = {})
+        requires!(options, :login)
+        super
+      end
+
+      def authorize(money, credit_card, options = {})
+        post = {}
+
+        add_amount(post, money)
+        add_invoice(post, options)
+        add_credit_card(post, credit_card)
+        unless credit_card.track_data.present?
+          add_address(post, credit_card, options)
+          add_customer_data(post, options)
+        end
+        add_split_payments(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)
+        unless credit_card.track_data.present?
+          add_address(post, credit_card, options)
+          add_customer_data(post, options)
+        end
+        add_split_payments(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 verify(creditcard, options = {})
+        MultiResponse.run(:use_first_response) do |r|
+          r.process { authorize(1, creditcard, options) }
+          r.process(:ignore_result) { void(r.authorization, options) }
+        end
+      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]
+        post[:description]  = options[:description]
+      end
+
+      def add_credit_card(post, credit_card)
+        if credit_card.track_data.present?
+          post[:magstripe] = credit_card.track_data
+          post[:cardpresent] = true
+        else
+          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
+      end
+
+      # see: http://wiki.usaepay.com/developer/transactionapi#split_payments
+      def add_split_payments(post, options)
+        return unless options[:split_payments].is_a?(Array)
+        options[:split_payments].each_with_index do |payment, index|
+          prefix = '%02d' % (index + 2)
+          post["#{prefix}key"]         = payment[:key]
+          post["#{prefix}amount"]      = amount(payment[:amount])
+          post["#{prefix}description"] = payment[:description]
+        end
+
+        # When blank it's 'Stop'. 'Continue' is another one
+        post['onError'] = options[:on_error] || 'Void'
+      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)
+        url = (test? ? self.test_url : self.live_url)
+        response = parse(ssl_post(url, post_data(action, parameters)))
+        Response.new(response[:status] == 'Approved', message_from(response), response,
+          :test           => test?,
+          :authorization  => response[:ref_num],
+          :cvv_result     => response[:cvv2_result_code],
+          :avs_result     => { :code => response[:avs_result_code] },
+          :error_code     => STANDARD_ERROR_CODE_MAPPING[response[:error_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,225 @@
+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
+
+      self.live_url = self.test_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)
+        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)
+          ActiveMerchant.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 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(self.live_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