activemerchant 1.100.0 → 1.133.0

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

@@ -0,0 +1,392 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class PriorityGateway < Gateway
+      # Sandbox and Production
+      self.test_url = 'https://sandbox.api.mxmerchant.com/checkout/v3/payment'
+      self.live_url = 'https://api.mxmerchant.com/checkout/v3/payment'
+
+      class_attribute :test_url_verify, :live_url_verify, :test_auth, :live_auth, :test_env_verify, :live_env_verify, :test_url_batch, :live_url_batch, :test_url_jwt, :live_url_jwt, :merchant
+
+      # Sandbox and Production - verify card
+      self.test_url_verify = 'https://sandbox-api2.mxmerchant.com/merchant/v1/bin'
+      self.live_url_verify = 'https://api2.mxmerchant.com/merchant/v1/bin'
+
+      # Sandbox and Production - check batch status
+      self.test_url_batch = 'https://sandbox.api.mxmerchant.com/checkout/v3/batch'
+      self.live_url_batch = 'https://api.mxmerchant.com/checkout/v3/batch'
+
+      # Sandbox and Production - generate jwt for verify card url
+      self.test_url_jwt = 'https://sandbox-api2.mxmerchant.com/security/v1/application/merchantId'
+      self.live_url_jwt = 'https://api2.mxmerchant.com/security/v1/application/merchantId'
+
+      self.supported_countries = ['US']
+      self.default_currency = 'USD'
+      self.supported_cardtypes = %i[visa master american_express discover]
+
+      self.homepage_url = 'https://mxmerchant.com/'
+      self.display_name = 'Priority'
+
+      def initialize(options = {})
+        requires!(options, :merchant_id, :api_key, :secret)
+        super
+      end
+
+      def basic_auth
+        Base64.strict_encode64("#{@options[:api_key]}:#{@options[:secret]}")
+      end
+
+      def request_headers
+        {
+          'Content-Type' => 'application/json',
+          'Authorization' => "Basic #{basic_auth}"
+        }
+      end
+
+      def request_verify_headers(jwt)
+        {
+          'Authorization' => "Bearer #{jwt}"
+        }
+      end
+
+      def purchase(amount, credit_card, options = {})
+        params = {}
+        params['authOnly'] = false
+        params['isSettleFunds'] = true
+
+        add_merchant_id(params)
+        add_amount(params, amount, options)
+        add_auth_purchase_params(params, credit_card, options)
+
+        commit('purchase', params: params)
+      end
+
+      def authorize(amount, credit_card, options = {})
+        params = {}
+        params['authOnly'] = true
+        params['isSettleFunds'] = false
+
+        add_merchant_id(params)
+        add_amount(params, amount, options)
+        add_auth_purchase_params(params, credit_card, options)
+
+        commit('purchase', params: params)
+      end
+
+      def credit(amount, credit_card, options = {})
+        params = {}
+        params['authOnly'] = false
+        params['isSettleFunds'] = true
+        amount = -amount
+
+        add_merchant_id(params)
+        add_amount(params, amount, options)
+        add_credit_params(params, credit_card, options)
+        commit('credit', params: params)
+      end
+
+      def refund(amount, authorization, options = {})
+        params = {}
+        add_merchant_id(params)
+        params['paymentToken'] = payment_token(authorization) || options[:payment_token]
+
+        # refund amounts must be negative
+        params['amount'] = ('-' + localized_amount(amount.to_f, options[:currency])).to_f
+
+        commit('refund', params: params)
+      end
+
+      def capture(amount, authorization, options = {})
+        params = {}
+        add_merchant_id(params)
+        add_amount(params, amount, options)
+        params['paymentToken'] = payment_token(authorization) || options[:payment_token]
+        params['tenderType'] = options[:tender_type].present? ? options[:tender_type] : 'Card'
+
+        commit('capture', params: params)
+      end
+
+      def void(authorization, options = {})
+        params = {}
+
+        commit('void', params: params, iid: payment_id(authorization))
+      end
+
+      def verify(credit_card, _options = {})
+        jwt = create_jwt.params['jwtToken']
+
+        commit('verify', card_number: credit_card.number, jwt: jwt)
+      end
+
+      def get_payment_status(batch_id)
+        commit('get_payment_status', params: batch_id)
+      end
+
+      def close_batch(batch_id)
+        commit('close_batch', params: batch_id)
+      end
+
+      def create_jwt
+        commit('create_jwt', params: @options[:merchant_id])
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((Authorization: Basic )\w+), '\1[FILTERED]').
+          gsub(%r((number\\?"\s*:\s*\\?")[^"]*)i, '\1[FILTERED]').
+          gsub(%r((cvv\\?"\s*:\s*\\?")[^"]*)i, '\1[FILTERED]')
+      end
+
+      private
+
+      def add_amount(params, amount, options)
+        params['amount'] = localized_amount(amount.to_f, options[:currency])
+      end
+
+      def add_merchant_id(params)
+        params['merchantId'] = @options[:merchant_id]
+      end
+
+      def add_auth_purchase_params(params, credit_card, options)
+        add_replay_id(params, options)
+        add_credit_card(params, credit_card, 'purchase', options)
+        add_purchases_data(params, options)
+        add_shipping_data(params, options)
+        add_pos_data(params, options)
+        add_additional_data(params, options)
+      end
+
+      def add_credit_params(params, credit_card, options)
+        add_replay_id(params, options)
+        add_credit_card(params, credit_card, 'purchase', options)
+        add_additional_data(params, options)
+      end
+
+      def add_replay_id(params, options)
+        params['replayId'] = options[:replay_id] if options[:replay_id]
+      end
+
+      def add_credit_card(params, credit_card, action, options)
+        return unless credit_card&.is_a?(CreditCard)
+
+        card_details = {}
+        card_details['expiryMonth'] = format(credit_card.month, :two_digits).to_s
+        card_details['expiryYear'] = format(credit_card.year, :two_digits).to_s
+        card_details['cardType'] = credit_card.brand
+        card_details['last4'] = credit_card.last_digits
+        card_details['cvv'] = credit_card.verification_value unless credit_card.verification_value.nil?
+        card_details['number'] = credit_card.number
+        card_details['avsStreet'] = options[:billing_address][:address1] if options[:billing_address]
+        card_details['avsZip'] =  options[:billing_address][:zip] if !options[:billing_address].nil? && !options[:billing_address][:zip].nil?
+
+        params['cardAccount'] = card_details
+      end
+
+      def exp_date(credit_card)
+        "#{format(credit_card.month, :two_digits)}/#{format(credit_card.year, :two_digits)}"
+      end
+
+      def add_additional_data(params, options)
+        params['isAuth'] = options[:is_auth].present? ? options[:is_auth] : 'true'
+        params['paymentType'] = options[:payment_type].present? ? options[:payment_type] : 'Sale'
+        params['tenderType'] = options[:tender_type].present? ? options[:tender_type] : 'Card'
+        params['taxExempt'] = options[:tax_exempt].present? ? options[:tax_exempt] : 'false'
+        params['taxAmount'] = options[:tax_amount] if options[:tax_amount]
+        params['shouldGetCreditCardLevel'] = options[:should_get_credit_card_level] if options[:should_get_credit_card_level]
+        params['source'] = options[:source] if options[:source]
+        params['invoice'] = options[:invoice] if options[:invoice]
+        params['isTicket'] = options[:is_ticket] if options[:is_ticket]
+        params['shouldVaultCard'] = options[:should_vault_card] if options[:should_vault_card]
+        params['sourceZip'] = options[:source_zip] if options[:source_zip]
+        params['authCode'] = options[:auth_code] if options[:auth_code]
+        params['achIndicator'] = options[:ach_indicator] if options[:ach_indicator]
+        params['bankAccount'] = options[:bank_account] if options[:bank_account]
+        params['meta'] = options[:meta] if options[:meta]
+      end
+
+      def add_pos_data(params, options)
+        pos_data = {}
+        pos_data['cardholderPresence'] = options.dig(:pos_data, :cardholder_presence) || 'Ecom'
+        pos_data['deviceAttendance'] = options.dig(:pos_data, :device_attendance) || 'HomePc'
+        pos_data['deviceInputCapability'] = options.dig(:pos_data, :device_input_capability) || 'Unknown'
+        pos_data['deviceLocation'] = options.dig(:pos_data, :device_location) || 'HomePc'
+        pos_data['panCaptureMethod'] = options.dig(:pos_data, :pan_capture_method) || 'Manual'
+        pos_data['partialApprovalSupport'] = options.dig(:pos_data, :partial_approval_support) || 'NotSupported'
+        pos_data['pinCaptureCapability'] = options.dig(:pos_data, :pin_capture_capability) || 'Incapable'
+
+        params['posData'] = pos_data
+      end
+
+      def add_purchases_data(params, options)
+        return unless options[:purchases]
+
+        params['purchases'] = []
+
+        options[:purchases].each do |purchase|
+          purchase_object = {}
+
+          purchase_object['name'] = purchase[:name] if purchase[:name]
+          purchase_object['description'] = purchase[:description] if purchase[:description]
+          purchase_object['code'] = purchase[:code] if purchase[:code]
+          purchase_object['unitOfMeasure'] = purchase[:unit_of_measure] if purchase[:unit_of_measure]
+          purchase_object['unitPrice'] = purchase[:unit_price] if purchase[:unit_price]
+          purchase_object['quantity'] = purchase[:quantity] if purchase[:quantity]
+          purchase_object['taxRate'] = purchase[:tax_rate] if purchase[:tax_rate]
+          purchase_object['taxAmount'] = purchase[:tax_amount] if purchase[:tax_amount]
+          purchase_object['discountRate'] = purchase[:discount_rate] if purchase[:discount_rate]
+          purchase_object['discountAmount'] = purchase[:discount_amount] if purchase[:discount_amount]
+          purchase_object['extendedAmount'] = purchase[:extended_amount] if purchase[:extended_amount]
+          purchase_object['lineItemId'] = purchase[:line_item_id] if purchase[:line_item_id]
+
+          params['purchases'].append(purchase_object)
+        end
+      end
+
+      def add_shipping_data(params, options)
+        params['shipAmount'] = options[:ship_amount] if options[:ship_amount]
+
+        shipping_country = shipping_country_from(options)
+        params['shipToCountry'] = shipping_country if shipping_country
+
+        shipping_zip = shipping_zip_from(options)
+        params['shipToZip'] = shipping_zip if shipping_zip
+      end
+
+      def shipping_country_from(options)
+        options[:ship_to_country] || options.dig(:shipping_address, :country) || options.dig(:billing_address, :country)
+      end
+
+      def shipping_zip_from(options)
+        options[:ship_to_zip] || options.dig(:shipping_addres, :zip) || options.dig(:billing_address, :zip)
+      end
+
+      def payment_token(authorization)
+        return unless authorization
+        return authorization unless authorization.include?('|')
+
+        authorization.split('|').last
+      end
+
+      def payment_id(authorization)
+        return unless authorization
+        return authorization unless authorization.include?('|')
+
+        authorization.split('|').first
+      end
+
+      def commit(action, params: '', iid: '', card_number: nil, jwt: '')
+        response =
+          begin
+            case action
+            when 'void'
+              parse(ssl_request(:delete, url(action, params, ref_number: iid), nil, request_headers))
+            when 'verify'
+              parse(ssl_get(url(action, params, credit_card_number: card_number), request_verify_headers(jwt)))
+            when 'get_payment_status', 'create_jwt'
+              parse(ssl_get(url(action, params, ref_number: iid), request_headers))
+            when 'close_batch'
+              parse(ssl_request(:put, url(action, params, ref_number: iid), nil, request_headers))
+            else
+              parse(ssl_post(url(action, params), post_data(params), request_headers))
+            end
+          rescue ResponseError => e
+            # currently Priority returns a 404 with no body on certain calls. In those cases we will substitute the response status from response.message
+            gateway_response = e.response.body.presence || e.response.message
+            parse(gateway_response)
+          end
+
+        success = success_from(response, action)
+        Response.new(
+          success,
+          message_from(response),
+          response,
+          authorization: success ? authorization_from(response) : nil,
+          error_code: success || response == '' ? nil : error_from(response),
+          test: test?
+        )
+      end
+
+      def url(action, params, ref_number: '', credit_card_number: nil)
+        case action
+        when 'void'
+          base_url + "/#{ref_number}?force=true"
+        when 'verify'
+          (verify_url + '?search=') + credit_card_number.to_s[0..6]
+        when 'get_payment_status', 'close_batch'
+          batch_url + "/#{params}"
+        when 'create_jwt'
+          jwt_url + "/#{params}/token"
+        else
+          base_url + '?includeCustomerMatches=false&echo=true'
+        end
+      end
+
+      def base_url
+        test? ? test_url : live_url
+      end
+
+      def verify_url
+        test? ? self.test_url_verify : self.live_url_verify
+      end
+
+      def jwt_url
+        test? ? self.test_url_jwt : self.live_url_jwt
+      end
+
+      def batch_url
+        test? ? self.test_url_batch : self.live_url_batch
+      end
+
+      def handle_response(response)
+        case response.code.to_i
+        when 204
+          { status: 'Success' }.to_json
+        when 200...300
+          response.body
+        else
+          raise ResponseError.new(response)
+        end
+      end
+
+      def parse(body)
+        return {} if body.blank?
+
+        parsed_response = JSON.parse(body)
+        parsed_response.is_a?(String) ? { 'message' => parsed_response } : parsed_response
+      rescue JSON::ParserError
+        message = 'Invalid JSON response received from Priority Gateway. Please contact Priority Gateway if you continue to receive this message.'
+        message += " (The raw response returned by the API was #{body.inspect})"
+        {
+          'message' => message
+        }
+      end
+
+      def success_from(response, action)
+        return !response['bank'].empty? if action == 'verify' && response['bank']
+
+        %w[Approved Open Success Settled Voided].include?(response['status'])
+      end
+
+      def message_from(response)
+        return response['details'][0] if response['details'] && response['details'][0]
+
+        response['authMessage'] || response['message'] || response['status']
+      end
+
+      def authorization_from(response)
+        [response['id'], response['paymentToken']].join('|')
+      end
+
+      def error_from(response)
+        response['errorCode'] || response['status']
+      end
+
+      def post_data(params)
+        params.to_json
+      end
+    end
+  end
+end

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

@@ -6,10 +6,10 @@ module ActiveMerchant #:nodoc:
       self.test_url = 'https://xmltest.propay.com/API/PropayAPI.aspx'
       self.live_url = 'https://epay.propay.com/api/propayapi.aspx'
 
-      self.supported_countries = ['US', 'CA']
+      self.supported_countries = %w[US CA]
       self.default_currency = 'USD'
       self.money_format = :cents
-      self.supported_cardtypes = [:visa, :master, :american_express, :discover]
+      self.supported_cardtypes = %i[visa master american_express discover]
 
       self.homepage_url = 'https://www.propay.com/'
       self.display_name = 'ProPay'
@@ -133,12 +133,12 @@ module ActiveMerchant #:nodoc:
         '99' => 'Generic decline or unable to parse issuer response code'
       }
 
-      def initialize(options={})
+      def initialize(options = {})
         requires!(options, :cert_str)
         super
       end
 
-      def purchase(money, payment, options={})
+      def purchase(money, payment, options = {})
         request = build_xml_request do |xml|
           add_invoice(xml, money, options)
           add_payment(xml, payment, options)
@@ -151,7 +151,7 @@ module ActiveMerchant #:nodoc:
         commit(request)
       end
 
-      def authorize(money, payment, options={})
+      def authorize(money, payment, options = {})
         request = build_xml_request do |xml|
           add_invoice(xml, money, options)
           add_payment(xml, payment, options)
@@ -164,7 +164,7 @@ module ActiveMerchant #:nodoc:
         commit(request)
       end
 
-      def capture(money, authorization, options={})
+      def capture(money, authorization, options = {})
         request = build_xml_request do |xml|
           add_invoice(xml, money, options)
           add_account(xml, options)
@@ -175,7 +175,7 @@ module ActiveMerchant #:nodoc:
         commit(request)
       end
 
-      def refund(money, authorization, options={})
+      def refund(money, authorization, options = {})
         request = build_xml_request do |xml|
           add_invoice(xml, money, options)
           add_account(xml, options)
@@ -186,11 +186,11 @@ module ActiveMerchant #:nodoc:
         commit(request)
       end
 
-      def void(authorization, options={})
+      def void(authorization, options = {})
         refund(nil, authorization, options)
       end
 
-      def credit(money, payment, options={})
+      def credit(money, payment, options = {})
         request = build_xml_request do |xml|
           add_invoice(xml, money, options)
           add_payment(xml, payment, options)
@@ -201,7 +201,7 @@ module ActiveMerchant #:nodoc:
         commit(request)
       end
 
-      def verify(credit_card, options={})
+      def verify(credit_card, options = {})
         MultiResponse.run(:use_first_response) do |r|
           r.process { authorize(100, credit_card, options) }
           r.process(:ignore_result) { void(r.authorization, options) }
@@ -253,7 +253,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def parse(body)
-        results  = {}
+        results = {}
         xml = Nokogiri::XML(body)
         resp = xml.xpath('//XMLResponse/XMLTrans')
         resp.children.each do |element|
@@ -284,6 +284,7 @@ module ActiveMerchant #:nodoc:
 
       def message_from(response)
         return 'Success' if success_from(response)
+
         message = STATUS_RESPONSE_CODES[response[:status]]
         message += " - #{TRANSACTION_RESPONSE_CODES[response[:response_code]]}" if response[:response_code]
 
@@ -295,9 +296,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def error_code_from(response)
-        unless success_from(response)
-          response[:status]
-        end
+        response[:status] unless success_from(response)
       end
 
       def build_xml_request

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

@@ -38,7 +38,7 @@ module ActiveMerchant #:nodoc:
       self.test_url  = 'https://realtimestaging.psigate.com/xml'
       self.live_url  = 'https://realtime.psigate.com/xml'
 
-      self.supported_cardtypes = [:visa, :master, :american_express]
+      self.supported_cardtypes = %i[visa master american_express]
       self.supported_countries = ['CA']
       self.homepage_url = 'http://www.psigate.com/'
       self.display_name = 'Psigate'
@@ -103,11 +103,10 @@ module ActiveMerchant #:nodoc:
         response = parse(ssl_post(url, post_data(money, creditcard, options)))
 
         Response.new(successful?(response), message_from(response), response,
-          :test => test?,
-          :authorization => build_authorization(response),
-          :avs_result => { :code => response[:avsresult] },
-          :cvv_result => response[:cardidresult]
-        )
+          test: test?,
+          authorization: build_authorization(response),
+          avs_result: { code: response[:avsresult] },
+          cvv_result: response[:cardidresult])
       end
 
       def url
@@ -119,7 +118,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def parse(xml)
-        response = {:message => 'Global Error Receipt', :complete => false}
+        response = { message: 'Global Error Receipt', complete: false }
 
         xml = REXML::Document.new(xml)
         xml.elements.each('//Result/*') do |node|
@@ -144,26 +143,26 @@ module ActiveMerchant #:nodoc:
       def parameters(money, creditcard, options = {})
         params = {
           # General order parameters
-          :StoreID => @options[:login],
-          :Passphrase => @options[:password],
-          :TestResult => options[:test_result],
-          :OrderID => options[:order_id],
-          :UserID => options[:user_id],
-          :Phone => options[:phone],
-          :Fax => options[:fax],
-          :Email => options[:email],
-          :TransRefNumber => options[:trans_ref_number],
+          StoreID: @options[:login],
+          Passphrase: @options[:password],
+          TestResult: options[:test_result],
+          OrderID: options[:order_id],
+          UserID: options[:user_id],
+          Phone: options[:phone],
+          Fax: options[:fax],
+          Email: options[:email],
+          TransRefNumber: options[:trans_ref_number],
 
           # Credit Card parameters
-          :PaymentType => 'CC',
-          :CardAction => options[:CardAction],
+          PaymentType: 'CC',
+          CardAction: options[:CardAction],
 
           # Financial parameters
-          :CustomerIP => options[:ip],
-          :SubTotal => amount(money),
-          :Tax1 => options[:tax1],
-          :Tax2 => options[:tax2],
-          :ShippingTotal => options[:shipping_total],
+          CustomerIP: options[:ip],
+          SubTotal: amount(money),
+          Tax1: options[:tax1],
+          Tax2: options[:tax2],
+          ShippingTotal: options[:shipping_total]
         }
 
         if creditcard
@@ -172,15 +171,15 @@ module ActiveMerchant #:nodoc:
           card_id_code = (creditcard.verification_value.blank? ? nil : '1')
 
           params.update(
-            :CardNumber => creditcard.number,
-            :CardExpMonth => exp_month,
-            :CardExpYear => exp_year,
-            :CardIDCode => card_id_code,
-            :CardIDNumber => creditcard.verification_value
+            CardNumber: creditcard.number,
+            CardExpMonth: exp_month,
+            CardExpYear: exp_year,
+            CardIDCode: card_id_code,
+            CardIDNumber: creditcard.verification_value
           )
         end
 
-        if(address = (options[:billing_address] || options[:address]))
+        if (address = (options[:billing_address] || options[:address]))
           params[:Bname] = address[:name] || creditcard.name
           params[:Baddress1]    = address[:address1] unless address[:address1].blank?
           params[:Baddress2]    = address[:address2] unless address[:address2].blank?
@@ -210,6 +209,7 @@ module ActiveMerchant #:nodoc:
           return SUCCESS_MESSAGE
         else
           return FAILURE_MESSAGE if response[:errmsg].blank?
+
           return response[:errmsg].gsub(/[^\w]/, ' ').split.join(' ').capitalize
         end
       end

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

@@ -21,7 +21,7 @@ module ActiveMerchant
       # American Express, Diners Club, JCB, International Maestro,
       # Style, Clydesdale Financial Services, Other
 
-      self.supported_cardtypes = [ :visa, :master, :american_express, :diners_club, :jcb, :maestro ]
+      self.supported_cardtypes = %i[visa master american_express diners_club jcb maestro]
       self.homepage_url = 'http://www.paymentsolutionsltd.com/'
       self.display_name = 'PSL Payment Solutions'
 
@@ -183,7 +183,7 @@ module ActiveMerchant
         address = options[:billing_address] || options[:address]
         return if address.nil?
 
-        post[:QAAddress] = [:address1, :address2, :city, :state].collect { |a| address[a] }.reject(&:blank?).join(' ')
+        post[:QAAddress] = %i[address1 address2 city state].collect { |a| address[a] }.reject(&:blank?).join(' ')
         post[:QAPostcode] = address[:zip]
       end
 
@@ -211,7 +211,7 @@ module ActiveMerchant
 
       def add_purchase_details(post)
         post[:EchoAmount] = 'YES'
-        post[:SCBI] = 'YES'                   # Return information about the transaction
+        post[:SCBI] = 'YES' # Return information about the transaction
         post[:MessageType] = MESSAGE_TYPE
       end
 
@@ -260,11 +260,10 @@ module ActiveMerchant
         response = parse(ssl_post(self.live_url, post_data(request)))
 
         Response.new(response[:ResponseCode] == APPROVED, response[:Message], response,
-          :test => test?,
-          :authorization => response[:CrossReference],
-          :cvv_result => CVV_CODE[response[:AVSCV2Check]],
-          :avs_result => { :code => AVS_CODE[response[:AVSCV2Check]] }
-        )
+          test: test?,
+          authorization: response[:CrossReference],
+          cvv_result: CVV_CODE[response[:AVSCV2Check]],
+          avs_result: { code: AVS_CODE[response[:AVSCV2Check]] })
       end
 
       # Put the passed data into a format that can be submitted to PSL