activemerchant 1.42.6 → 1.90.0

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

@@ -0,0 +1,245 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class PayConexGateway < Gateway
+      include Empty
+
+      self.test_url = 'https://cert.payconex.net/api/qsapi/3.8/'
+      self.live_url = 'https://secure.payconex.net/api/qsapi/3.8/'
+
+      self.supported_countries = %w(US CA)
+      self.default_currency = 'USD'
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover, :jcb, :diners_club]
+
+      self.homepage_url = 'http://www.bluefincommerce.com/'
+      self.display_name = 'PayConex'
+
+      def initialize(options={})
+        requires!(options, :account_id, :api_accesskey)
+        super
+      end
+
+      def purchase(money, payment_method, options={})
+        post = {}
+        add_auth_purchase_params(post, money, payment_method, options)
+        commit('SALE', post)
+      end
+
+      def authorize(money, payment_method, options={})
+        post = {}
+        add_auth_purchase_params(post, money, payment_method, options)
+        commit('AUTHORIZATION', post)
+      end
+
+      def capture(money, authorization, options={})
+        post = {}
+        add_reference_params(post, authorization, options)
+        add_amount(post, money, options)
+        commit('CAPTURE', post)
+      end
+
+      def refund(money, authorization, options={})
+        post = {}
+        add_reference_params(post, authorization, options)
+        add_amount(post, money, options)
+        commit('REFUND', post)
+      end
+
+      def void(authorization, options = {})
+        post = {}
+        add_reference_params(post, authorization, options)
+        commit('REVERSAL', post)
+      end
+
+      def credit(money, payment_method, options={})
+        if payment_method.is_a?(String)
+          raise ArgumentError, 'Reference credits are not supported. Please supply the original credit card or use the #refund method.'
+        end
+
+        post = {}
+        add_auth_purchase_params(post, money, payment_method, options)
+        commit('CREDIT', post)
+      end
+
+      def verify(payment_method, options={})
+        authorize(0, payment_method, options)
+      end
+
+      def store(payment_method, options={})
+        post = {}
+        add_credentials(post)
+        add_payment_method(post, payment_method)
+        add_address(post, options)
+        add_common_options(post, options)
+        commit('STORE', post)
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        force_utf8(transcript).
+          gsub(%r((api_accesskey=)\w+), '\1[FILTERED]').
+          gsub(%r((card_number=)\w+), '\1[FILTERED]').
+          gsub(%r((card_verification=)\w+), '\1[FILTERED]')
+      end
+
+      private
+
+      def force_utf8(string)
+        return nil unless string
+        binary = string.encode('BINARY', invalid: :replace, undef: :replace, replace: '?')   # Needed for Ruby 2.0 since #encode is a no-op if the string is already UTF-8. It's not needed for Ruby 2.1 and up since it's not a no-op there.
+        binary.encode('UTF-8', invalid: :replace, undef: :replace, replace: '?')
+      end
+
+      def add_credentials(post)
+        post[:account_id] = @options[:account_id]
+        post[:api_accesskey] = @options[:api_accesskey]
+      end
+
+      def add_auth_purchase_params(post, money, payment_method, options)
+        add_credentials(post)
+        add_payment_method(post, payment_method)
+        add_address(post, options)
+        add_common_options(post, options)
+        add_amount(post, money, options)
+        add_if_present(post, :email, options[:email])
+      end
+
+      def add_reference_params(post, authorization, options)
+        add_credentials(post)
+        add_common_options(post, options)
+        add_token_id(post, authorization)
+      end
+
+      def add_amount(post, money, options)
+        post[:transaction_amount] = amount(money)
+        currency_code = (options[:currency] || currency(money))
+        add_if_present(post, :currency, currency_code)
+      end
+
+      def add_payment_method(post, payment_method)
+        case payment_method
+        when String
+          add_token_payment_method(post, payment_method)
+        when Check
+          add_check(post, payment_method)
+        else
+          if payment_method.respond_to?(:track_data) && payment_method.track_data.present?
+            add_card_present_payment_method(post, payment_method)
+          else
+            add_credit_card(post, payment_method)
+          end
+        end
+      end
+
+      def add_credit_card(post, payment_method)
+        post[:tender_type] = 'CARD'
+        post[:card_number] = payment_method.number
+        post[:card_expiration] = expdate(payment_method)
+        post[:card_verification] = payment_method.verification_value
+        post[:first_name] = payment_method.first_name
+        post[:last_name] = payment_method.last_name
+      end
+
+      def add_token_payment_method(post, payment_method)
+        post[:tender_type] = 'CARD'
+        post[:token_id] = payment_method
+        post[:reissue] = true
+      end
+
+      def add_card_present_payment_method(post, payment_method)
+        post[:tender_type] = 'CARD'
+        post[:card_tracks] = payment_method.track_data
+      end
+
+      def add_check(post, payment_method)
+        post[:tender_type] = 'ACH'
+        post[:first_name] = payment_method.first_name
+        post[:last_name] = payment_method.last_name
+        post[:bank_account_number] = payment_method.account_number
+        post[:bank_routing_number] = payment_method.routing_number
+        post[:check_number] = payment_method.number
+        add_if_present(post, :ach_account_type, payment_method.account_type)
+      end
+
+      def add_address(post, options)
+        address = options[:billing_address]
+        return unless address
+
+        add_if_present(post, :street_address1, address[:address1])
+        add_if_present(post, :street_address2, address[:address2])
+        add_if_present(post, :city, address[:city])
+        add_if_present(post, :state, address[:state])
+        add_if_present(post, :zip, address[:zip])
+        add_if_present(post, :country, address[:country])
+        add_if_present(post, :phone, address[:phone])
+      end
+
+      def add_common_options(post, options)
+        add_if_present(post, :transaction_description, options[:description])
+        add_if_present(post, :custom_id, options[:custom_id])
+        add_if_present(post, :custom_data, options[:custom_data])
+        add_if_present(post, :ip_address, options[:ip])
+        add_if_present(post, :payment_type, options[:payment_type])
+        add_if_present(post, :cashier, options[:cashier])
+
+        post[:disable_cvv] = options[:disable_cvv] unless options[:disable_cvv].nil?
+        post[:response_format] = 'JSON'
+      end
+
+      def add_if_present(post, key, value)
+        post[key] = value unless empty?(value)
+      end
+
+      def add_token_id(post, authorization)
+        post[:token_id] = authorization
+      end
+
+      def parse(body)
+        JSON.parse(body)
+      end
+
+      def commit(action, params)
+        raw_response = ssl_post(url, post_data(action, params))
+        response = parse(raw_response)
+
+        Response.new(
+          success_from(response),
+          message_from(response),
+          response,
+          authorization: response['transaction_id'],
+          :avs_result => AVSResult.new(code: response['avs_response']),
+          :cvv_result => CVVResult.new(response['cvv2_response']),
+          test: test?
+        )
+      rescue JSON::ParserError
+        unparsable_response(raw_response)
+      end
+
+      def url
+        test? ? test_url : live_url
+      end
+
+      def success_from(response)
+        response['transaction_approved'] || !response['error']
+      end
+
+      def message_from(response)
+        success_from(response) ? response['authorization_message'] : response['error_message']
+      end
+
+      def post_data(action, params)
+        params[:transaction_type] = action
+        params.map { |k, v| "#{k}=#{CGI.escape(v.to_s)}" }.join('&')
+      end
+
+      def unparsable_response(raw_response)
+        message = 'Invalid JSON response received from PayConex. Please contact PayConex if you continue to receive this message.'
+        message += " (The raw response returned by the API was #{raw_response.inspect})"
+        return Response.new(false, message)
+      end
+
+    end
+  end
+end

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

@@ -52,7 +52,7 @@ module ActiveMerchant #:nodoc:
     #
     # PayGateXML Field        ActiveMerchant Use
     #
-    # pgid                    use :login value to gateway instantation
+    # pgid                    use :login value to gateway instantiation
     # pwd                     use :password value to gateway instantiation
     #
     # cname                   credit_card.name
@@ -102,45 +102,45 @@ module ActiveMerchant #:nodoc:
 
       DECLINE_CODES = {
         # Credit Card Errors - These RESULT_CODEs are returned if the transaction cannot be authorized due to a problem with the card.  The TRANSACTION_STATUS will be 2
-        900001  => "Call for Approval",
-        900002  => "Card Expired",
-        900003  => "Insufficient Funds",
-        900004  => "Invalid Card Number",
-        900005  => "Bank Interface Timeout",  # indicates a communications failure between the banks systems
-        900006  => "Invalid Card",
-        900007  => "Declined",
-        900009  => "Lost Card",
-        900010  => "Invalid Card Length",
-        900011  => "Suspected Fraud",
-        900012  => "Card Reported As Stolen",
-        900013  => "Restricted Card",
-        900014  => "Excessive Card Usage",
-        900015  => "Card Blacklisted",
-
-        900207  => "Declined; authentication failed",  # indicates the cardholder did not enter their MasterCard SecureCode / Verified by Visa password correctly
-
-        990020  => "Auth Declined",
-
-        991001  => "Invalid expiry date",
-        991002  => "Invalid amount",
+        900001  => 'Call for Approval',
+        900002  => 'Card Expired',
+        900003  => 'Insufficient Funds',
+        900004  => 'Invalid Card Number',
+        900005  => 'Bank Interface Timeout',  # indicates a communications failure between the banks systems
+        900006  => 'Invalid Card',
+        900007  => 'Declined',
+        900009  => 'Lost Card',
+        900010  => 'Invalid Card Length',
+        900011  => 'Suspected Fraud',
+        900012  => 'Card Reported As Stolen',
+        900013  => 'Restricted Card',
+        900014  => 'Excessive Card Usage',
+        900015  => 'Card Blacklisted',
+
+        900207  => 'Declined; authentication failed',  # indicates the cardholder did not enter their MasterCard SecureCode / Verified by Visa password correctly
+
+        990020  => 'Auth Declined',
+
+        991001  => 'Invalid expiry date',
+        991002  => 'Invalid amount',
 
         # Communication Errors - These RESULT_CODEs are returned if the transaction cannot be completed due to an unexpected error.  TRANSACTION_STATUS will be 0.
-        900205  => "Unexpected authentication result (phase 1)",
-        900206  => "Unexpected authentication result (phase 1)",
+        900205  => 'Unexpected authentication result (phase 1)',
+        900206  => 'Unexpected authentication result (phase 1)',
 
-        990001  => "Could not insert into Database",
+        990001  => 'Could not insert into Database',
 
-        990022  => "Bank not available",
+        990022  => 'Bank not available',
 
-        990053  => "Error processing transaction",
+        990053  => 'Error processing transaction',
 
         # Miscellaneous - Unless otherwise noted, the TRANSACTION_STATUS will be 0.
-        900209  => "Transaction verification failed (phase 2)",  # Indicates the verification data returned from MasterCard SecureCode / Verified by Visa has been altered
-        900210  => "Authentication complete; transaction must be restarted",  # Indicates that the MasterCard SecuerCode / Verified by Visa transaction has already been completed.  Most likely caused by the customer clicking the refresh button
+        900209  => 'Transaction verification failed (phase 2)',  # Indicates the verification data returned from MasterCard SecureCode / Verified by Visa has been altered
+        900210  => 'Authentication complete; transaction must be restarted',  # Indicates that the MasterCard SecuerCode / Verified by Visa transaction has already been completed.  Most likely caused by the customer clicking the refresh button
 
-        990024  => "Duplicate Transaction Detected.  Please check before submitting",
+        990024  => 'Duplicate Transaction Detected.  Please check before submitting',
 
-        990028  => "Transaction cancelled"  # Customer clicks the 'Cancel' button on the payment page
+        990028  => 'Transaction cancelled'  # Customer clicks the 'Cancel' button on the payment page
       }
 
       SUCCESS_CODES = %w( 990004 990005 990017 990012 990018 990031 )
@@ -162,22 +162,32 @@ module ActiveMerchant #:nodoc:
 
       def purchase(money, creditcard, options = {})
         MultiResponse.run do |r|
-          r.process{authorize(money, creditcard, options)}
-          r.process{capture(money, r.authorization, options)}
+          r.process { authorize(money, creditcard, options) }
+          r.process { capture(money, r.authorization, options) }
         end
       end
 
       def authorize(money, creditcard, options = {})
         action = 'authtx'
 
-        options.merge!(:money => money, :creditcard => creditcard)
+        options[:money] = money
+        options[:creditcard] = creditcard
         commit(action, build_request(action, options))
       end
 
       def capture(money, authorization, options = {})
         action = 'settletx'
 
-        options.merge!(:money => money, :authorization => authorization)
+        options[:money] = money
+        options[:authorization] = authorization
+        commit(action, build_request(action, options), authorization)
+      end
+
+      def refund(money, authorization, options={})
+        action = 'refundtx'
+
+        options[:money] = money
+        options[:authorization] = authorization
         commit(action, build_request(action, options))
       end
 
@@ -192,17 +202,18 @@ module ActiveMerchant #:nodoc:
         xml.instruct!
 
         xml.tag! 'protocol', :ver => API_VERSION, :pgid => (test? ? TEST_ID : @options[:login]), :pwd => @options[:password] do |protocol|
+          money         = options.delete(:money)
+          authorization = options.delete(:authorization)
+          creditcard    = options.delete(:creditcard)
           case action
-            when 'authtx'
-              money       = options.delete(:money)
-              creditcard  = options.delete(:creditcard)
-              build_authorization(protocol, money, creditcard, options)
-            when 'settletx'
-              money           = options.delete(:money)
-              authorization   = options.delete(:authorization)
-              build_capture(protocol, money, authorization, options)
+          when 'authtx'
+            build_authorization(protocol, money, creditcard, options)
+          when 'settletx'
+            build_capture(protocol, money, authorization, options)
+          when 'refundtx'
+            build_refund(protocol, money, authorization, options)
           else
-            raise "no action specified for build_request"
+            raise 'no action specified for build_request'
           end
         end
 
@@ -218,7 +229,9 @@ module ActiveMerchant #:nodoc:
           :budp  => 0,
           :amt   => amount(money),
           :cur   => (options[:currency] || currency(money)),
-          :cvv   => creditcard.verification_value
+          :cvv   => creditcard.verification_value,
+          :email => options[:email],
+          :ip    => options[:ip]
         }
       end
 
@@ -228,6 +241,13 @@ module ActiveMerchant #:nodoc:
         }
       end
 
+      def build_refund(xml, money, authorization, options={})
+        xml.tag! 'refundtx', {
+          :tid => authorization,
+          :amt => amount(money)
+        }
+      end
+
       def parse(action, body)
         hash  = {}
         xml   = REXML::Document.new(body)
@@ -244,11 +264,11 @@ module ActiveMerchant #:nodoc:
         hash
       end
 
-      def commit(action, request)
+      def commit(action, request, authorization = nil)
         response = parse(action, ssl_post(self.live_url, request))
         Response.new(successful?(response), message_from(response), response,
           :test           => test?,
-          :authorization  => response[:tid]
+          :authorization  => authorization || response[:tid]
         )
       end
 
@@ -258,4 +278,3 @@ module ActiveMerchant #:nodoc:
     end
   end
 end
-

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

@@ -0,0 +1,213 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class PayHubGateway < Gateway
+      self.live_url = 'https://checkout.payhub.com/transaction/api'
+
+      self.supported_countries = ['US']
+      self.default_currency = 'USD'
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover]
+
+      self.homepage_url = 'http://www.payhub.com/'
+      self.display_name = 'PayHub'
+
+      CVV_CODE_TRANSLATOR = {
+        'M' => 'CVV matches',
+        'N' => 'CVV does not match',
+        'P' => 'CVV not processed',
+        'S' => 'CVV should have been present',
+        'U' => 'CVV request unable to be processed by issuer'
+      }
+
+      AVS_CODE_TRANSLATOR = {
+        '0' =>  'Approved, Address verification was not requested.',
+        'A' =>  'Approved, Address matches only.',
+        'B' =>  'Address Match. Street Address math for international transaction Postal Code not verified because of incompatible formats (Acquirer sent both street address and Postal Code)',
+        'C' =>  'Serv Unavailable. Street address and Postal Code not verified for international transaction because of incompatible formats (Acquirer sent both street and Postal Code).',
+        'D' =>  'Exact Match, Street Address and Postal Code match for international transaction.',
+        'F' =>  'Exact Match, Street Address and Postal Code match. Applies to UK only.',
+        'G' =>  'Ver Unavailable, Non-U.S. Issuer does not participate.',
+        'I' =>  'Ver Unavailable, Address information not verified for international transaction',
+        'M' =>  'Exact Match, Street Address and Postal Code match for international transaction',
+        'N' =>  'No - Address and ZIP Code does not match',
+        'P' =>  'Zip Match, Postal Codes match for international transaction Street address not verified because of incompatible formats (Acquirer sent both street address and Postal Code).',
+        'R' =>  'Retry - Issuer system unavailable',
+        'S' =>  'Serv Unavailable, Service not supported',
+        'U' =>  'Ver Unavailable, Address unavailable.',
+        'W' =>  'ZIP match - Nine character numeric ZIP match only.',
+        'X' =>  'Exact match, Address and nine-character ZIP match.',
+        'Y' =>  'Exact Match, Address and five character ZIP match.',
+        'Z' =>  'Zip Match, Five character numeric ZIP match only.',
+        '1' =>  'Cardholder name and ZIP match AMEX only.',
+        '2' =>  'Cardholder name, address, and ZIP match AMEX only.',
+        '3' =>  'Cardholder name and address match AMEX only.',
+        '4' =>  'Cardholder name match AMEX only.',
+        '5' =>  'Cardholder name incorrect, ZIP match AMEX only.',
+        '6' =>  'Cardholder name incorrect, address and ZIP match AMEX only.',
+        '7' =>  'Cardholder name incorrect, address match AMEX only.',
+        '8' =>  'Cardholder, all do not match AMEX only.'
+      }
+
+      STANDARD_ERROR_CODE_MAPPING = {
+        '14' => STANDARD_ERROR_CODE[:invalid_number],
+        '80' => STANDARD_ERROR_CODE[:invalid_expiry_date],
+        '82' => STANDARD_ERROR_CODE[:invalid_cvc],
+        '54' => STANDARD_ERROR_CODE[:expired_card],
+        '51' => STANDARD_ERROR_CODE[:card_declined],
+        '05' => STANDARD_ERROR_CODE[:card_declined],
+        '61' => STANDARD_ERROR_CODE[:card_declined],
+        '62' => STANDARD_ERROR_CODE[:card_declined],
+        '65' => STANDARD_ERROR_CODE[:card_declined],
+        '93' => STANDARD_ERROR_CODE[:card_declined],
+        '01' => STANDARD_ERROR_CODE[:call_issuer],
+        '02' => STANDARD_ERROR_CODE[:call_issuer],
+        '04' => STANDARD_ERROR_CODE[:pickup_card],
+        '07' => STANDARD_ERROR_CODE[:pickup_card],
+        '41' => STANDARD_ERROR_CODE[:pickup_card],
+        '43' => STANDARD_ERROR_CODE[:pickup_card]
+      }
+
+      def initialize(options={})
+        requires!(options, :orgid, :username, :password, :tid)
+
+        super
+      end
+
+      def authorize(amount, creditcard, options = {})
+        post = setup_post('auth')
+        add_creditcard(post, creditcard)
+        add_amount(post, amount)
+        add_address(post, (options[:address] || options[:billing_address]))
+        add_customer_data(post, options)
+
+        commit(post)
+      end
+
+      def purchase(amount, creditcard, options={})
+        post = setup_post('sale')
+        add_creditcard(post, creditcard)
+        add_amount(post, amount)
+        add_address(post, (options[:address] || options[:billing_address]))
+        add_customer_data(post, options)
+
+        commit(post)
+      end
+
+      def refund(amount, trans_id, options={})
+        # Attempt a void in case the transaction is unsettled
+        post = setup_post('void')
+        add_reference(post, trans_id)
+        response = commit(post)
+        return response if response.success?
+
+        post = setup_post('refund')
+        add_reference(post, trans_id)
+        commit(post)
+      end
+
+      def capture(amount, trans_id, options = {})
+        post = setup_post('capture')
+
+        add_reference(post, trans_id)
+        add_amount(post, amount)
+
+        commit(post)
+      end
+
+      # No void, as PayHub's void does not work on authorizations
+
+      def verify(creditcard, options={})
+        authorize(100, creditcard, options)
+      end
+
+      private
+
+      def setup_post(action)
+        post = {}
+        post[:orgid] = @options[:orgid]
+        post[:tid] = @options[:tid]
+        post[:username] = @options[:username]
+        post[:password] = @options[:password]
+        post[:mode] = (test? ? 'demo' : 'live')
+        post[:trans_type] = action
+        post
+      end
+
+      def add_reference(post, trans_id)
+        post[:trans_id] = trans_id
+      end
+
+      def add_customer_data(post, options = {})
+        post[:first_name] = options[:first_name]
+        post[:last_name] = options[:last_name]
+        post[:phone] = options[:phone]
+        post[:email] = options[:email]
+      end
+
+      def add_address(post, address)
+        return unless address
+        post[:address1] = address[:address1]
+        post[:address2] = address[:address2]
+        post[:zip] = address[:zip]
+        post[:state] = address[:state]
+        post[:city] = address[:city]
+      end
+
+      def add_amount(post, amount)
+        post[:amount] =  amount(amount)
+      end
+
+      def add_creditcard(post, creditcard)
+        post[:cc] = creditcard.number
+        post[:month] = creditcard.month.to_s
+        post[:year] = creditcard.year.to_s
+        post[:cvv] = creditcard.verification_value
+      end
+
+      def parse(body)
+        JSON.parse(body)
+      end
+
+      def commit(post)
+        success = false
+
+        begin
+          raw_response = ssl_post(live_url, post.to_json, {'Content-Type' => 'application/json'})
+          response = parse(raw_response)
+          success = (response['RESPONSE_CODE'] == '00')
+        rescue ResponseError => e
+          raw_response = e.response.body
+          response = response_error(raw_response)
+        rescue JSON::ParserError
+          response = json_error(raw_response)
+        end
+
+        Response.new(success,
+          response_message(response),
+          response,
+          test: test?,
+          avs_result: {code: response['AVS_RESULT_CODE']},
+          cvv_result: response['VERIFICATION_RESULT_CODE'],
+          error_code: (success ? nil : STANDARD_ERROR_CODE_MAPPING[response['RESPONSE_CODE']]),
+          authorization: response['TRANSACTION_ID']
+        )
+      end
+
+      def response_error(raw_response)
+        parse(raw_response)
+      rescue JSON::ParserError
+        json_error(raw_response)
+      end
+
+      def json_error(raw_response)
+        {
+          error_message: 'Invalid response received from the Payhub API.  Please contact wecare@payhub.com if you continue to receive this message.' \
+            "  (The raw response returned by the API was #{raw_response.inspect})"
+        }
+      end
+
+      def response_message(response)
+        (response['RESPONSE_TEXT'] || response['RESPONSE_CODE'] || response[:error_message])
+      end
+    end
+  end
+end