activemerchant 1.113.0 → 1.119.0

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

@@ -204,7 +204,7 @@ module ActiveMerchant #:nodoc:
         perform_reference_credit(money, reference, options)
       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) }
@@ -432,9 +432,9 @@ module ActiveMerchant #:nodoc:
             raise "Unknown signature algorithm #{algorithm}"
           end
 
-        filtered_params = signed_parameters.select { |k, v| !v.blank? }
+        filtered_params = signed_parameters.select { |_k, v| !v.blank? }
         sha_encryptor.hexdigest(
-          filtered_params.sort_by { |k, v| k.upcase }.map { |k, v| "#{k.upcase}=#{v}#{secret}" }.join('')
+          filtered_params.sort_by { |k, _v| k.upcase }.map { |k, v| "#{k.upcase}=#{v}#{secret}" }.join('')
         ).upcase
       end
 

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

@@ -46,7 +46,7 @@ module ActiveMerchant #:nodoc:
       # * <tt>:api_version</tt> -- Omise's API Version (OPTIONAL), default version is '2014-07-27'
       #                            See version at page https://dashboard.omise.co/api-version/edit
 
-      def initialize(options={})
+      def initialize(options = {})
         requires!(options, :public_key, :secret_key)
         @public_key  = options[:public_key]
         @secret_key  = options[:secret_key]
@@ -79,7 +79,7 @@ module ActiveMerchant #:nodoc:
       #
       #   purchase(money, nil, { :customer_id => customer_id })
 
-      def purchase(money, payment_method, options={})
+      def purchase(money, payment_method, options = {})
         create_charge(money, payment_method, options)
       end
 
@@ -91,7 +91,7 @@ module ActiveMerchant #:nodoc:
       # * <tt>payment_method</tt> -- The CreditCard object
       # * <tt>options</tt>        -- An optional parameters, such as token or capture
 
-      def authorize(money, payment_method, options={})
+      def authorize(money, payment_method, options = {})
         options[:capture] = 'false'
         create_charge(money, payment_method, options)
       end
@@ -104,7 +104,7 @@ module ActiveMerchant #:nodoc:
       # * <tt>charge_id</tt> -- The CreditCard object
       # * <tt>options</tt>   -- An optional parameters, such as token or capture
 
-      def capture(money, charge_id, options={})
+      def capture(money, charge_id, options = {})
         post = {}
         add_amount(post, money, options)
         commit(:post, "charges/#{CGI.escape(charge_id)}/capture", post, options)
@@ -118,7 +118,7 @@ module ActiveMerchant #:nodoc:
       # * <tt>charge_id</tt> -- The CreditCard object
       # * <tt>options</tt>   -- An optional parameters, such as token or capture
 
-      def refund(money, charge_id, options={})
+      def refund(money, charge_id, options = {})
         options[:amount] = money if money
         commit(:post, "charges/#{CGI.escape(charge_id)}/refunds", options)
       end
@@ -132,7 +132,7 @@ module ActiveMerchant #:nodoc:
       #     'email'       (A customer email)
       #     'description' (A customer description)
 
-      def store(payment_method, options={})
+      def store(payment_method, options = {})
         post, card_params = {}, {}
         add_customer_data(post, options)
         add_token(card_params, payment_method, options)
@@ -145,7 +145,7 @@ module ActiveMerchant #:nodoc:
       #
       # * <tt>customer_id</tt> -- The Customer identifier (REQUIRED).
 
-      def unstore(customer_id, options={})
+      def unstore(customer_id, options = {})
         commit(:delete, "customers/#{CGI.escape(customer_id)}")
       end
 
@@ -178,7 +178,7 @@ module ActiveMerchant #:nodoc:
         commit(:post, 'charges', post, options)
       end
 
-      def headers(options={})
+      def headers(options = {})
         key = options[:key] || @secret_key
         {
           'Content-Type'    => 'application/json;utf-8',
@@ -197,7 +197,7 @@ module ActiveMerchant #:nodoc:
         parameters.present? ? parameters.to_json : nil
       end
 
-      def https_request(method, endpoint, parameters=nil, options={})
+      def https_request(method, endpoint, parameters = nil, options = {})
         raw_response = response = nil
         begin
           raw_response = ssl_request(method, url_for(endpoint), post_data(parameters), headers(options))
@@ -221,7 +221,7 @@ module ActiveMerchant #:nodoc:
         { message: msg }
       end
 
-      def commit(method, endpoint, params=nil, options={})
+      def commit(method, endpoint, params = nil, options = {})
         response = https_request(method, endpoint, params, options)
         Response.new(
           successful?(response),
@@ -284,7 +284,7 @@ module ActiveMerchant #:nodoc:
         commit(:post, 'tokens', post, { key: @public_key })
       end
 
-      def add_token(post, credit_card, options={})
+      def add_token(post, credit_card, options = {})
         if options[:token_id].present?
           post[:card] = options[:token_id]
         else
@@ -304,11 +304,11 @@ module ActiveMerchant #:nodoc:
         post[:card] = card
       end
 
-      def add_customer(post, options={})
+      def add_customer(post, options = {})
         post[:customer] = options[:customer_id] if options[:customer_id]
       end
 
-      def add_customer_data(post, options={})
+      def add_customer_data(post, options = {})
         post[:description] = options[:description] if options[:description]
         post[:email]       = options[:email] if options[:email]
       end

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

@@ -116,7 +116,7 @@ module ActiveMerchant #:nodoc:
         post[:device_session_id] = options[:device_session_id]
         post[:currency] = (options[:currency] || currency(money)).upcase
         post[:use_card_points] = options[:use_card_points] if options[:use_card_points]
-        post[:payment_plan] = {payments: options[:payments]} if options[:payments]
+        post[:payment_plan] = { payments: options[:payments] } if options[:payments]
         add_creditcard(post, creditcard, options)
         post
       end
@@ -188,11 +188,10 @@ module ActiveMerchant #:nodoc:
           (success ? response['error_code'] : response['description']),
           response,
           test: test?,
-          authorization: response['id']
-        )
+          authorization: response['id'])
       end
 
-      def http_request(method, resource, parameters={}, options={})
+      def http_request(method, resource, parameters = {}, options = {})
         url = (test? ? self.test_url : self.live_url) + @merchant_id + '/' + resource
         raw_response = nil
         begin

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

@@ -117,39 +117,39 @@ module ActiveMerchant #:nodoc:
       self.homepage_url = 'https://docs.oppwa.com'
       self.display_name = 'Open Payment Platform'
 
-      def initialize(options={})
+      def initialize(options = {})
         requires!(options, :access_token, :entity_id)
         super
       end
 
-      def purchase(money, payment, options={})
+      def purchase(money, payment, options = {})
         # debit
         options[:registrationId] = payment if payment.is_a?(String)
         execute_dbpa(options[:risk_workflow] ? 'PA.CP' : 'DB',
           money, payment, options)
       end
 
-      def authorize(money, payment, options={})
+      def authorize(money, payment, options = {})
         # preauthorization PA
         execute_dbpa('PA', money, payment, options)
       end
 
-      def capture(money, authorization, options={})
+      def capture(money, authorization, options = {})
         # capture CP
         execute_referencing('CP', money, authorization, options)
       end
 
-      def refund(money, authorization, options={})
+      def refund(money, authorization, options = {})
         # refund RF
         execute_referencing('RF', money, authorization, options)
       end
 
-      def void(authorization, options={})
+      def void(authorization, options = {})
         # reversal RV
         execute_referencing('RV', nil, authorization, options)
       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) }
@@ -287,7 +287,7 @@ module ActiveMerchant #:nodoc:
       def add_options(post, options)
         post[:createRegistration] = options[:create_registration] if options[:create_registration] && !options[:registrationId]
         post[:testMode] = options[:test_mode] if test? && options[:test_mode]
-        options.each { |key, value| post[key] = value if key.to_s.match('customParameters\[[a-zA-Z0-9\._]{3,64}\]') }
+        options.each { |key, value| post[key] = value if key.to_s =~ /'customParameters\[[a-zA-Z0-9\._]{3,64}\]'/ }
         post['customParameters[SHOPPER_pluginId]'] = 'activemerchant'
         post['customParameters[custom_disable3DSecure]'] = options[:disable_3d_secure] if options[:disable_3d_secure]
       end
@@ -349,7 +349,7 @@ module ActiveMerchant #:nodoc:
 
       def json_error(body)
         message = "Invalid response received #{body.inspect}"
-        { 'result' => {'description' => message, 'code' => 'unknown' } }
+        { 'result' => { 'description' => message, 'code' => 'unknown' } }
       end
 
       def success_from(response)

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

@@ -125,8 +125,7 @@ module ActiveMerchant #:nodoc:
           test: test?,
           authorization: authorization_from(response),
           avs_result: { code: avs_result_from(response) },
-          cvv_result: cvv_result_from(response)
-        )
+          cvv_result: cvv_result_from(response))
       end
 
       # The upstream is picky and so we can't use CGI.escape like we want to
@@ -257,7 +256,7 @@ module ActiveMerchant #:nodoc:
       def schema
         { 'xmlns' => 'http://www.optimalpayments.com/creditcard/xmlschema/v1',
           'xmlns:xsi' => 'http://www.w3.org/2001/XMLSchema-instance',
-          'xsi:schemaLocation' => 'http://www.optimalpayments.com/creditcard/xmlschema/v1'}
+          'xsi:schemaLocation' => 'http://www.optimalpayments.com/creditcard/xmlschema/v1' }
       end
 
       def build_merchant_account(xml)

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

@@ -30,11 +30,11 @@ module ActiveMerchant #:nodoc:
     class OrbitalGateway < Gateway
       include Empty
 
-      API_VERSION = '7.7'
+      API_VERSION = '8.1'
 
       POST_HEADERS = {
         'MIME-Version' => '1.1',
-        'Content-Type' => "application/PTI#{API_VERSION.gsub(/\./, '')}",
+        'Content-Type' => "application/PTI#{API_VERSION.delete('.')}",
         'Content-transfer-encoding' => 'text',
         'Request-number' => '1',
         'Document-type' => 'Request',
@@ -60,7 +60,8 @@ module ActiveMerchant #:nodoc:
         '93', # Approved high fraud
         '94', # Approved fraud service unavailable
         'E7', # Stored
-        'PA'  # Partial approval
+        'PA', # Partial approval
+        'P1'  # ECP - AVS - Account Status Verification and/or AOA data is in a positive status.
       ]
 
       class_attribute :secondary_test_url, :secondary_live_url
@@ -183,6 +184,37 @@ module ActiveMerchant #:nodoc:
 
       SENSITIVE_FIELDS = %i[account_num cc_account_num]
 
+      # Bank account types to be used for check processing
+      ACCOUNT_TYPE = {
+        'savings' => 'S',
+        'checking' => 'C'
+      }
+
+      # Fixed possible values for orbital ECP attributes
+      # Auth methods for electronic checks can be:
+      # Written, Internet, Telephonic, Account Receivable, Point of Purchase.
+      # Default auth method for ECP is Internet (I).
+      # Bank payment delivery can be either ACH (Automated Clearing House) or Best Possible.
+      # Default Bank Payment Delivery is Best Possible (B).
+      # Action codes to be used for Early Warning System and additional validations.
+      # Valid combinations of Message Type and Action Code to be used are:
+      #   A   W1
+      #   AC  W1
+      #   FC  W4
+      #   R   W6
+      #   FC  W8
+      #   A   W3
+      #   AC  W3
+      #   FC  W5
+      #   R   W7
+      # Default Action code for ECP is nil.
+      # Electronic check to be processed on same day (Y) or next day (N).
+      # Default ECP Same Day Index is Yes (Y).
+      ECP_AUTH_METHODS = %w[W I T A P]
+      ECP_BANK_PAYMENT = %w[A B]
+      ECP_ACTION_CODES = %w[LO ND NC W1 W3 W4 W5 W6 W7 W8 W9]
+      ECP_SAME_DAY = %w[Y N]
+
       def initialize(options = {})
         requires!(options, :merchant_id)
         requires!(options, :login, :password) unless options[:ip_authentication]
@@ -191,12 +223,12 @@ module ActiveMerchant #:nodoc:
       end
 
       # A – Authorization request
-      def authorize(money, creditcard, options = {})
-        order = build_new_order_xml(AUTH_ONLY, money, creditcard, options) do |xml|
-          add_creditcard(xml, creditcard, options[:currency])
-          add_address(xml, creditcard, options)
+      def authorize(money, payment_source, options = {})
+        order = build_new_order_xml(AUTH_ONLY, money, payment_source, options) do |xml|
+          add_payment_source(xml, payment_source, options)
+          add_address(xml, payment_source, options)
           if @options[:customer_profiles]
-            add_customer_data(xml, creditcard, options)
+            add_customer_data(xml, payment_source, options)
             add_managed_billing(xml, options)
           end
         end
@@ -211,12 +243,12 @@ module ActiveMerchant #:nodoc:
       end
 
       # AC – Authorization and Capture
-      def purchase(money, creditcard, options = {})
-        order = build_new_order_xml(AUTH_AND_CAPTURE, money, creditcard, options) do |xml|
-          add_creditcard(xml, creditcard, options[:currency])
-          add_address(xml, creditcard, options)
+      def purchase(money, payment_source, options = {})
+        order = build_new_order_xml(options[:force_capture] ? FORCE_AUTH_AND_CAPTURE : AUTH_AND_CAPTURE, money, payment_source, options) do |xml|
+          add_payment_source(xml, payment_source, options)
+          add_address(xml, payment_source, options)
           if @options[:customer_profiles]
-            add_customer_data(xml, creditcard, options)
+            add_customer_data(xml, payment_source, options)
             add_managed_billing(xml, options)
           end
         end
@@ -237,7 +269,7 @@ module ActiveMerchant #:nodoc:
         commit(order, :refund, options[:trace_number])
       end
 
-      def credit(money, authorization, options= {})
+      def credit(money, authorization, options = {})
         ActiveMerchant.deprecated CREDIT_DEPRECATION_MESSAGE
         refund(money, authorization, options)
       end
@@ -286,13 +318,13 @@ module ActiveMerchant #:nodoc:
       end
 
       def retrieve_customer_profile(customer_ref_num)
-        options = {customer_profile_action: RETRIEVE, customer_ref_num: customer_ref_num}
+        options = { customer_profile_action: RETRIEVE, customer_ref_num: customer_ref_num }
         order = build_customer_request_xml(nil, options)
         commit(order, :retrieve_customer_profile)
       end
 
       def delete_customer_profile(customer_ref_num)
-        options = {customer_profile_action: DELETE, customer_ref_num: customer_ref_num}
+        options = { customer_profile_action: DELETE, customer_ref_num: customer_ref_num }
         order = build_customer_request_xml(nil, options)
         commit(order, :delete_customer_profile)
       end
@@ -310,7 +342,8 @@ module ActiveMerchant #:nodoc:
           gsub(%r((<CCAccountNum>).+(</CC)), '\1[FILTERED]\2').
           gsub(%r((<CardSecVal>).+(</CardSecVal>)), '\1[FILTERED]\2').
           gsub(%r((<MerchantID>).+(</MerchantID>)), '\1[FILTERED]\2').
-          gsub(%r((<CustomerMerchantID>).+(</CustomerMerchantID>)), '\1[FILTERED]\2')
+          gsub(%r((<CustomerMerchantID>).+(</CustomerMerchantID>)), '\1[FILTERED]\2').
+          gsub(%r((<CustomerProfileMessage>).+(</CustomerProfileMessage>)), '\1[FILTERED]\2')
       end
 
       private
@@ -355,61 +388,61 @@ module ActiveMerchant #:nodoc:
         xml.tag! :SDMerchantEmail, soft_desc[:merchant_email] || nil
       end
 
-      def add_level_2_tax(xml, options={})
-        if (level_2 = options[:level_2_data])
-          xml.tag! :TaxInd, level_2[:tax_indicator] if [TAX_NOT_PROVIDED, TAX_INCLUDED, NON_TAXABLE_TRANSACTION].include?(level_2[:tax_indicator].to_i)
-          xml.tag! :Tax, level_2[:tax].to_i if level_2[:tax]
+      def add_level2_tax(xml, options = {})
+        if (level2 = options[:level_2_data])
+          xml.tag! :TaxInd, level2[:tax_indicator] if [TAX_NOT_PROVIDED, TAX_INCLUDED, NON_TAXABLE_TRANSACTION].include?(level2[:tax_indicator].to_i)
+          xml.tag! :Tax, level2[:tax].to_i if level2[:tax]
         end
       end
 
-      def add_level_3_tax(xml, options={})
-        if (level_3 = options[:level_3_data])
-          xml.tag! :PC3VATtaxAmt, byte_limit(level_3[:vat_tax], 12) if level_3[:vat_tax]
-          xml.tag! :PC3AltTaxAmt, byte_limit(level_3[:alt_tax], 9) if level_3[:alt_tax]
-          xml.tag! :PC3VATtaxRate, byte_limit(level_3[:vat_rate], 4) if level_3[:vat_rate]
-          xml.tag! :PC3AltTaxInd, byte_limit(level_3[:alt_ind], 15) if level_3[:alt_ind]
+      def add_level3_tax(xml, options = {})
+        if (level3 = options[:level_3_data])
+          xml.tag! :PC3VATtaxAmt, byte_limit(level3[:vat_tax], 12) if level3[:vat_tax]
+          xml.tag! :PC3AltTaxAmt, byte_limit(level3[:alt_tax], 9) if level3[:alt_tax]
+          xml.tag! :PC3VATtaxRate, byte_limit(level3[:vat_rate], 4) if level3[:vat_rate]
+          xml.tag! :PC3AltTaxInd, byte_limit(level3[:alt_ind], 15) if level3[:alt_ind]
         end
       end
 
-      def add_level_2_advice_addendum(xml, options={})
-        if (level_2 = options[:level_2_data])
-          xml.tag! :AMEXTranAdvAddn1, byte_limit(level_2[:advice_addendum_1], 40) if level_2[:advice_addendum_1]
-          xml.tag! :AMEXTranAdvAddn2, byte_limit(level_2[:advice_addendum_2], 40) if level_2[:advice_addendum_2]
-          xml.tag! :AMEXTranAdvAddn3, byte_limit(level_2[:advice_addendum_3], 40) if level_2[:advice_addendum_3]
-          xml.tag! :AMEXTranAdvAddn4, byte_limit(level_2[:advice_addendum_4], 40) if level_2[:advice_addendum_4]
+      def add_level2_advice_addendum(xml, options = {})
+        if (level2 = options[:level_2_data])
+          xml.tag! :AMEXTranAdvAddn1, byte_limit(level2[:advice_addendum_1], 40) if level2[:advice_addendum_1]
+          xml.tag! :AMEXTranAdvAddn2, byte_limit(level2[:advice_addendum_2], 40) if level2[:advice_addendum_2]
+          xml.tag! :AMEXTranAdvAddn3, byte_limit(level2[:advice_addendum_3], 40) if level2[:advice_addendum_3]
+          xml.tag! :AMEXTranAdvAddn4, byte_limit(level2[:advice_addendum_4], 40) if level2[:advice_addendum_4]
         end
       end
 
-      def add_level_2_purchase(xml, options={})
-        if (level_2 = options[:level_2_data])
-          xml.tag! :PCOrderNum,       byte_limit(level_2[:purchase_order], 17) if level_2[:purchase_order]
-          xml.tag! :PCDestZip,        byte_limit(format_address_field(level_2[:zip]), 10) if level_2[:zip]
-          xml.tag! :PCDestName,       byte_limit(format_address_field(level_2[:name]), 30) if level_2[:name]
-          xml.tag! :PCDestAddress1,   byte_limit(format_address_field(level_2[:address1]), 30) if level_2[:address1]
-          xml.tag! :PCDestAddress2,   byte_limit(format_address_field(level_2[:address2]), 30) if level_2[:address2]
-          xml.tag! :PCDestCity,       byte_limit(format_address_field(level_2[:city]), 20) if level_2[:city]
-          xml.tag! :PCDestState,      byte_limit(format_address_field(level_2[:state]), 2) if level_2[:state]
+      def add_level2_purchase(xml, options = {})
+        if (level2 = options[:level_2_data])
+          xml.tag! :PCOrderNum,       byte_limit(level2[:purchase_order], 17) if level2[:purchase_order]
+          xml.tag! :PCDestZip,        byte_limit(format_address_field(level2[:zip]), 10) if level2[:zip]
+          xml.tag! :PCDestName,       byte_limit(format_address_field(level2[:name]), 30) if level2[:name]
+          xml.tag! :PCDestAddress1,   byte_limit(format_address_field(level2[:address1]), 30) if level2[:address1]
+          xml.tag! :PCDestAddress2,   byte_limit(format_address_field(level2[:address2]), 30) if level2[:address2]
+          xml.tag! :PCDestCity,       byte_limit(format_address_field(level2[:city]), 20) if level2[:city]
+          xml.tag! :PCDestState,      byte_limit(format_address_field(level2[:state]), 2) if level2[:state]
         end
       end
 
-      def add_level_3_purchase(xml, options={})
-        if (level_3 = options[:level_3_data])
-          xml.tag! :PC3FreightAmt,    byte_limit(level_3[:freight_amount], 12) if level_3[:freight_amount]
-          xml.tag! :PC3DutyAmt,       byte_limit(level_3[:duty_amount], 12) if level_3[:duty_amount]
-          xml.tag! :PC3DestCountryCd, byte_limit(level_3[:dest_country], 3) if level_3[:dest_country]
-          xml.tag! :PC3ShipFromZip,   byte_limit(level_3[:ship_from_zip], 10) if level_3[:ship_from_zip]
-          xml.tag! :PC3DiscAmt,       byte_limit(level_3[:discount_amount], 12) if level_3[:discount_amount]
+      def add_level3_purchase(xml, options = {})
+        if (level3 = options[:level_3_data])
+          xml.tag! :PC3FreightAmt,    byte_limit(level3[:freight_amount], 12) if level3[:freight_amount]
+          xml.tag! :PC3DutyAmt,       byte_limit(level3[:duty_amount], 12) if level3[:duty_amount]
+          xml.tag! :PC3DestCountryCd, byte_limit(level3[:dest_country], 3) if level3[:dest_country]
+          xml.tag! :PC3ShipFromZip,   byte_limit(level3[:ship_from_zip], 10) if level3[:ship_from_zip]
+          xml.tag! :PC3DiscAmt,       byte_limit(level3[:discount_amount], 12) if level3[:discount_amount]
         end
       end
 
-      def add_line_items(xml, options={})
+      def add_line_items(xml, options = {})
         xml.tag! :PC3LineItemCount, byte_limit(options[:line_items].count, 2)
         xml.tag! :PC3LineItemArray do
           options[:line_items].each_with_index do |line_item, index|
             xml.tag! :PC3LineItem do
               xml.tag! :PC3DtlIndex,  byte_limit(index + 1, 2)
               line_item.each do |key, value|
-                if key == :line_tot
+                if [:line_tot, 'line_tot'].include? key
                   formatted_key = :PC3Dtllinetot
                 else
                   formatted_key = "PC3Dtl#{key.to_s.camelize}".to_sym
@@ -478,7 +511,32 @@ module ActiveMerchant #:nodoc:
         end
       end
 
-      def add_creditcard(xml, creditcard, currency=nil)
+      # Payment can be done through either Credit Card or Electronic Check
+      def add_payment_source(xml, payment_source, options = {})
+        if payment_source.is_a?(Check)
+          add_echeck(xml, payment_source, options)
+        else
+          add_creditcard(xml, payment_source, options[:currency])
+        end
+      end
+
+      # Adds Electronic Check attributes
+      def add_echeck(xml, check, options = {})
+        xml.tag! :CardBrand, 'EC'
+        xml.tag! :CurrencyCode, currency_code(options[:currency])
+        xml.tag! :CurrencyExponent, currency_exponents(options[:currency])
+        unless check.nil?
+
+          xml.tag! :BCRtNum, check.routing_number
+          xml.tag! :CheckDDA, check.account_number if check.account_number
+          xml.tag! :BankAccountType, ACCOUNT_TYPE[check.account_type] if ACCOUNT_TYPE[check.account_type]
+          xml.tag! :ECPAuthMethod, options[:auth_method] if options[:auth_method] && ECP_AUTH_METHODS.include?(options[:auth_method])
+          xml.tag! :BankPmtDelv, options[:payment_delivery] if options[:payment_delivery] && ECP_BANK_PAYMENT.include?(options[:payment_delivery])
+        end
+      end
+
+      # Adds Credit Card attributes
+      def add_creditcard(xml, creditcard, currency = nil)
         unless creditcard.nil?
           xml.tag! :AccountNum, creditcard.number
           xml.tag! :Exp, expiry_date(creditcard)
@@ -515,13 +573,9 @@ module ActiveMerchant #:nodoc:
       end
 
       def add_xid(xml, creditcard, three_d_secure)
-        xid = if three_d_secure && creditcard.brand == 'visa'
-                three_d_secure[:xid]
-              elsif creditcard.is_a?(NetworkTokenizationCreditCard)
-                creditcard.transaction_id
-              end
+        return unless three_d_secure && creditcard.brand == 'visa'
 
-        xml.tag!(:XID, xid) if xid
+        xml.tag!(:XID, three_d_secure[:xid]) if three_d_secure[:xid]
       end
 
       def add_cavv(xml, creditcard, three_d_secure)
@@ -536,6 +590,24 @@ module ActiveMerchant #:nodoc:
         xml.tag!(:AAV, three_d_secure[:cavv])
       end
 
+      def add_mc_program_protocol(xml, creditcard, three_d_secure)
+        return unless three_d_secure && creditcard.brand == 'master'
+
+        xml.tag!(:MCProgramProtocol, three_d_secure[:version]) if three_d_secure[:version]
+      end
+
+      def add_mc_directory_trans_id(xml, creditcard, three_d_secure)
+        return unless three_d_secure && creditcard.brand == 'master'
+
+        xml.tag!(:MCDirectoryTransID, three_d_secure[:ds_transaction_id]) if three_d_secure[:ds_transaction_id]
+      end
+
+      def add_ucafind(xml, creditcard, three_d_secure)
+        return unless three_d_secure && creditcard.brand == 'master'
+
+        xml.tag! :UCAFInd, '4'
+      end
+
       def add_dpanind(xml, creditcard)
         return unless creditcard.is_a?(NetworkTokenizationCreditCard)
 
@@ -560,7 +632,7 @@ module ActiveMerchant #:nodoc:
         xml.tag!(:PymtBrandProgramCode, 'ASK')
       end
 
-      def add_refund(xml, currency=nil)
+      def add_refund(xml, currency = nil)
         xml.tag! :AccountNum, nil
 
         xml.tag! :CurrencyCode, currency_code(currency)
@@ -591,6 +663,40 @@ module ActiveMerchant #:nodoc:
         end
       end
 
+      def add_ews_details(xml, payment_source, parameters = {})
+        xml.tag! :EWSFirstName, payment_source.first_name
+        xml.tag! :EWSLastName, payment_source.last_name
+        xml.tag! :EWSBusinessName, parameters[:company] if payment_source.first_name.empty? && payment_source.last_name.empty?
+
+        if (address = (parameters[:billing_address] || parameters[:address]))
+          xml.tag! :EWSAddressLine1, byte_limit(format_address_field(address[:address1]), 30)
+          xml.tag! :EWSAddressLine2, byte_limit(format_address_field(address[:address2]), 30)
+          xml.tag! :EWSCity, byte_limit(format_address_field(address[:city]), 20)
+          xml.tag! :EWSState, byte_limit(format_address_field(address[:state]), 2)
+          xml.tag! :EWSZip, byte_limit(format_address_field(address[:zip]), 10)
+        end
+
+        xml.tag! :EWSPhoneType, parameters[:phone_type]
+        xml.tag! :EWSPhoneNumber, parameters[:phone_number]
+        xml.tag! :EWSCheckSerialNumber, payment_source.account_number unless parameters[:auth_method].eql?('I')
+      end
+
+      # Adds ECP conditional attributes depending on other attribute values
+      def add_ecp_details(xml, payment_source, parameters = {})
+        requires!(payment_source.account_number) if parameters[:auth_method]&.eql?('A') || parameters[:auth_method]&.eql?('P')
+        xml.tag! :ECPActionCode, parameters[:action_code] if parameters[:action_code] && ECP_ACTION_CODES.include?(parameters[:action_code])
+        xml.tag! :ECPCheckSerialNumber, payment_source.account_number if parameters[:auth_method]&.eql?('A') || parameters[:auth_method]&.eql?('P')
+        if parameters[:auth_method]&.eql?('P')
+          xml.tag! :ECPTerminalCity, parameters[:terminal_city] if parameters[:terminal_city]
+          xml.tag! :ECPTerminalState, parameters[:terminal_state] if parameters[:terminal_state]
+          xml.tag! :ECPImageReferenceNumber, parameters[:image_reference_number] if parameters[:image_reference_number]
+        end
+        if parameters[:action_code]&.eql?('W3') || parameters[:action_code]&.eql?('W5') ||
+           parameters[:action_code]&.eql?('W7') || parameters[:action_code]&.eql?('W9')
+          add_ews_details(xml, payment_source, parameters)
+        end
+      end
+
       def add_stored_credentials(xml, parameters)
         return unless parameters[:mit_stored_credential_ind] == 'Y' || parameters[:stored_credential] && !parameters[:stored_credential].values.all?(&:nil?)
 
@@ -647,7 +753,7 @@ module ActiveMerchant #:nodoc:
         end
       end
 
-      def commit(order, message_type, trace_number=nil)
+      def commit(order, message_type, trace_number = nil)
         headers = POST_HEADERS.merge('Content-length' => order.size.to_s)
         if @options[:retry_logic] && trace_number
           headers['Trace-number'] = trace_number.to_s
@@ -669,11 +775,10 @@ module ActiveMerchant #:nodoc:
             test: self.test?,
             avs_result: OrbitalGateway::AVSResult.new(response[:avs_resp_code]),
             cvv_result: OrbitalGateway::CVVResult.new(response[:cvv2_resp_code])
-          }
-        )
+          })
       end
 
-      def remote_url(url=:primary)
+      def remote_url(url = :primary)
         if url == :primary
           (self.test? ? self.test_url : self.live_url)
         else
@@ -700,7 +805,7 @@ module ActiveMerchant #:nodoc:
         @options[:ip_authentication] == true
       end
 
-      def build_new_order_xml(action, money, creditcard, parameters = {})
+      def build_new_order_xml(action, money, payment_source, parameters = {})
         requires!(parameters, :order_id)
         xml = xml_envelope
         xml.tag! :Request do
@@ -725,30 +830,32 @@ module ActiveMerchant #:nodoc:
 
             three_d_secure = parameters[:three_d_secure]
 
-            add_eci(xml, creditcard, three_d_secure)
-            add_cavv(xml, creditcard, three_d_secure)
-            add_xid(xml, creditcard, three_d_secure)
+            add_eci(xml, payment_source, three_d_secure)
+            add_cavv(xml, payment_source, three_d_secure)
+            add_xid(xml, payment_source, three_d_secure)
 
             xml.tag! :OrderID, format_order_id(parameters[:order_id])
             xml.tag! :Amount, amount(money)
             xml.tag! :Comments, parameters[:comments] if parameters[:comments]
 
-            add_level_2_tax(xml, parameters)
-            add_level_2_advice_addendum(xml, parameters)
+            add_level2_tax(xml, parameters)
+            add_level2_advice_addendum(xml, parameters)
 
-            add_aav(xml, creditcard, three_d_secure)
+            add_aav(xml, payment_source, three_d_secure)
             # CustomerAni, AVSPhoneType and AVSDestPhoneType could be added here.
 
-            add_dpanind(xml, creditcard)
-            add_aevv(xml, creditcard, three_d_secure)
-            add_digital_token_cryptogram(xml, creditcard)
-
             if parameters[:soft_descriptors].is_a?(OrbitalSoftDescriptors)
               add_soft_descriptors(xml, parameters[:soft_descriptors])
             elsif parameters[:soft_descriptors].is_a?(Hash)
               add_soft_descriptors_from_hash(xml, parameters[:soft_descriptors])
             end
 
+            add_dpanind(xml, payment_source)
+            add_aevv(xml, payment_source, three_d_secure)
+            add_digital_token_cryptogram(xml, payment_source)
+
+            xml.tag! :ECPSameDayInd, parameters[:same_day] if parameters[:same_day] && ECP_SAME_DAY.include?(parameters[:same_day]) && payment_source.is_a?(Check)
+
             set_recurring_ind(xml, parameters)
 
             # Append Transaction Reference Number at the end for Refund transactions
@@ -757,13 +864,17 @@ module ActiveMerchant #:nodoc:
               xml.tag! :TxRefNum, tx_ref_num
             end
 
-            add_level_2_purchase(xml, parameters)
-            add_level_3_purchase(xml, parameters)
-            add_level_3_tax(xml, parameters)
-            add_card_indicators(xml, parameters)
+            add_level2_purchase(xml, parameters)
+            add_level3_purchase(xml, parameters)
+            add_level3_tax(xml, parameters)
             add_line_items(xml, parameters) if parameters[:line_items]
+            add_ecp_details(xml, payment_source, parameters) if payment_source.is_a?(Check)
+            add_card_indicators(xml, parameters)
             add_stored_credentials(xml, parameters)
-            add_pymt_brand_program_code(xml, creditcard, three_d_secure)
+            add_pymt_brand_program_code(xml, payment_source, three_d_secure)
+            add_mc_program_protocol(xml, payment_source, three_d_secure)
+            add_mc_directory_trans_id(xml, payment_source, three_d_secure)
+            add_ucafind(xml, payment_source, three_d_secure)
           end
         end
         xml.target!
@@ -788,13 +899,13 @@ module ActiveMerchant #:nodoc:
             add_xml_credentials(xml)
             xml.tag! :OrderID, format_order_id(order_id)
             xml.tag! :Amount, amount(money)
-            add_level_2_tax(xml, parameters)
+            add_level2_tax(xml, parameters)
             add_bin_merchant_and_terminal(xml, parameters)
             xml.tag! :TxRefNum, tx_ref_num
-            add_level_2_purchase(xml, parameters)
-            add_level_2_advice_addendum(xml, parameters)
-            add_level_3_purchase(xml, parameters)
-            add_level_3_tax(xml, parameters)
+            add_level2_purchase(xml, parameters)
+            add_level2_advice_addendum(xml, parameters)
+            add_level3_purchase(xml, parameters)
+            add_level3_tax(xml, parameters)
           end
         end
         xml.target!
@@ -864,7 +975,7 @@ module ActiveMerchant #:nodoc:
       # 3. PINless Debit transactions can only use uppercase and lowercase alpha (A-Z, a-z) and numeric (0-9)
       def format_order_id(order_id)
         illegal_characters = /[^,$@&\- \w]/
-        order_id = order_id.to_s.gsub(/\./, '-')
+        order_id = order_id.to_s.tr('.', '-')
         order_id.gsub!(illegal_characters, '')
         order_id.lstrip!
         order_id[0...22]