class ActiveMerchant::Billing::OrbitalGateway

For more information on Orbital, visit the integration center

Authentication Options

The Orbital Gateway supports two methods of authenticating incoming requests: Source IP authentication and Connection Username/Password authentication

In addition, these IP addresses/Connection Usernames must be affiliated with the Merchant IDs for which the client should be submitting transactions.

This does allow Third Party Hosting service organizations presenting on behalf of other merchants to submit transactions. However, each time a new customer is added, the merchant or Third-Party hosting organization needs to ensure that the new Merchant IDs or Chain IDs are affiliated with the hosting companies IPs or Connection Usernames.

If the merchant expects to have more than one merchant account with the Orbital Gateway, it should have its IP addresses/Connection Usernames affiliated at the Chain level hierarchy within the Orbital Gateway. Each time a new merchant ID is added, as long as it is placed within the same Chain, it will simply work. Otherwise, the additional MIDs will need to be affiliated with the merchant IPs or Connection Usernames respectively. For example, we generally affiliate all Salem accounts [BIN 000001] with their Company Number [formerly called MA #] number so all MIDs or Divisions under that Company will automatically be affiliated.

Constants

ACTIVE

Status Profile Status Flag This field is used to set the status of a Customer Profile.

API_VERSION
APPROVED
AUTH_AND_CAPTURE

AC - Auth and Capture = 'AC'

AUTH_ONLY

Auth Only No Capture

AUTO_GENERATE
CustomerProfileFromOrderInd

Method to use to Generate the Customer Profile Number When Customer Profile Action Type = Create, defines what the Customer Profile Number will be:

AVS_SUPPORTED_COUNTRIES
CREATE

Customer Profile Actions

CURRENCY_CODES
CURRENCY_EXPONENTS
DEFERRED
DELETE
ECOMMERCE_TRANSACTION

INDUSTRY TYPES

FORCE_AUTH_AND_CAPTURE

FR - Force Auth No Capture and no online authorization = 'FR' FC - Force Auth and Capture no online authorization = 'FC'

FORCE_AUTH_ONLY

F - Force Auth No Capture and no online authorization = 'F'

INACTIVE
INTERACTIVE_VOICE_RESPONSE
MAIL_ORDER_TELEPHONE_ORDER_TRANSACTION
MANUAL_SUSPEND
NON_TAXABLE_TRANSACTION
NO_MAPPING_TO_ORDER_DATA

CustomerProfileOrderOverrideInd Defines if any Order Data can be pre-populated from the Customer Reference Number (CustomerRefNum)

POST_HEADERS
RECURRING
RECURRING_PAYMENT_TRANSACTION
REFUND

Refund and Capture no online authorization

RETRIEVE
SENSITIVE_FIELDS
SUCCESS
TAX_INCLUDED
TAX_NOT_PROVIDED

Tax Inds

UPDATE
USE_COMMENTS
USE_CRN_FOR_COMMENTS
USE_CRN_FOR_ORDER_ID
USE_CRN_FOR_ORDER_ID_AND_COMMENTS
USE_CUSTOMER_REF_NUM
USE_ORDER_ID

Public Class Methods

new(options = {}) click to toggle source
Calls superclass method ActiveMerchant::Billing::Gateway::new
# File lib/active_merchant/billing/gateways/orbital.rb, line 186
def initialize(options = {})
  requires!(options, :merchant_id)
  requires!(options, :login, :password) unless options[:ip_authentication]
  super
  @options[:merchant_id] = @options[:merchant_id].to_s
end

Public Instance Methods

add_customer_profile(creditcard, options = {}) click to toggle source

Customer Profiles

:customer_ref_num should be set unless you're happy with Orbital providing one

:customer_profile_order_override_ind can be set to map the CustomerRefNum to OrderID or Comments. Defaults to 'NO' - no mapping

'NO' - No mapping to order data
'OI' - Use <CustomerRefNum> for <OrderID>
'OD' - Use <CustomerRefNum> for <Comments>
'OA' - Use <CustomerRefNum> for <OrderID> and <Comments>

:order_default_description can be set optionally. 64 char max.

:order_default_amount can be set optionally. integer as cents.

:status defaults to Active

'A' - Active
'I' - Inactive
'MS'  - Manual Suspend
# File lib/active_merchant/billing/gateways/orbital.rb, line 276
def add_customer_profile(creditcard, options = {})
  options[:customer_profile_action] = CREATE
  order = build_customer_request_xml(creditcard, options)
  commit(order, :add_customer_profile)
end
authorize(money, creditcard, options = {}) click to toggle source

A – Authorization request

# File lib/active_merchant/billing/gateways/orbital.rb, line 194
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)
    if @options[:customer_profiles]
      add_customer_data(xml, creditcard, options)
      add_managed_billing(xml, options)
    end
  end
  commit(order, :authorize, options[:trace_number])
end
capture(money, authorization, options = {}) click to toggle source

MFC - Mark For Capture

# File lib/active_merchant/billing/gateways/orbital.rb, line 227
def capture(money, authorization, options = {})
  commit(build_mark_for_capture_xml(money, authorization, options), :capture)
end
credit(money, authorization, options= {}) click to toggle source
# File lib/active_merchant/billing/gateways/orbital.rb, line 240
def credit(money, authorization, options= {})
  ActiveMerchant.deprecated CREDIT_DEPRECATION_MESSAGE
  refund(money, authorization, options)
end
delete_customer_profile(customer_ref_num) click to toggle source
# File lib/active_merchant/billing/gateways/orbital.rb, line 294
def delete_customer_profile(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
purchase(money, creditcard, options = {}) click to toggle source

AC – Authorization and Capture

# File lib/active_merchant/billing/gateways/orbital.rb, line 214
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)
    if @options[:customer_profiles]
      add_customer_data(xml, creditcard, options)
      add_managed_billing(xml, options)
    end
  end
  commit(order, :purchase, options[:trace_number])
end
refund(money, authorization, options = {}) click to toggle source

R – Refund request

# File lib/active_merchant/billing/gateways/orbital.rb, line 232
def refund(money, authorization, options = {})
  order = build_new_order_xml(REFUND, money, nil, options.merge(:authorization => authorization)) do |xml|
    add_refund(xml, options[:currency])
    xml.tag! :CustomerRefNum, options[:customer_ref_num] if @options[:customer_profiles] && options[:profile_txn]
  end
  commit(order, :refund, options[:trace_number])
end
retrieve_customer_profile(customer_ref_num) click to toggle source
# File lib/active_merchant/billing/gateways/orbital.rb, line 288
def retrieve_customer_profile(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
scrub(transcript) click to toggle source
# File lib/active_merchant/billing/gateways/orbital.rb, line 304
def scrub(transcript)
  transcript.
    gsub(%r((<OrbitalConnectionUsername>).+(</OrbitalConnectionUsername>)), '\1[FILTERED]\2').
    gsub(%r((<OrbitalConnectionPassword>).+(</OrbitalConnectionPassword>)), '\1[FILTERED]\2').
    gsub(%r((<AccountNum>).+(</AccountNum>)), '\1[FILTERED]\2').
    gsub(%r((<CCAccountNum>).+(</CCAccountNum>)), '\1[FILTERED]\2').
    gsub(%r((<CardSecVal>).+(</CardSecVal>)), '\1[FILTERED]\2').
    gsub(%r((<MerchantID>).+(</MerchantID>)), '\1[FILTERED]\2').
    gsub(%r((<CustomerMerchantID>).+(</CustomerMerchantID>)), '\1[FILTERED]\2')
end
supports_scrubbing?() click to toggle source
# File lib/active_merchant/billing/gateways/orbital.rb, line 300
def supports_scrubbing?
  true
end
update_customer_profile(creditcard, options = {}) click to toggle source
# File lib/active_merchant/billing/gateways/orbital.rb, line 282
def update_customer_profile(creditcard, options = {})
  options[:customer_profile_action] = UPDATE
  order = build_customer_request_xml(creditcard, options)
  commit(order, :update_customer_profile)
end
verify(creditcard, options = {}) click to toggle source
# File lib/active_merchant/billing/gateways/orbital.rb, line 206
def verify(creditcard, options = {})
  MultiResponse.run(:use_first_response) do |r|
    r.process { authorize(100, creditcard, options) }
    r.process(:ignore_result) { void(r.authorization) }
  end
end
void(authorization, options = {}, deprecated = {}) click to toggle source
# File lib/active_merchant/billing/gateways/orbital.rb, line 245
def void(authorization, options = {}, deprecated = {})
  if(!options.kind_of?(Hash))
    ActiveMerchant.deprecated('Calling the void method with an amount parameter is deprecated and will be removed in a future version.')
    return void(options, deprecated.merge(:amount => authorization))
  end

  order = build_void_request_xml(authorization, options)
  commit(order, :void, options[:trace_number])
end

Private Instance Methods

add_aav(xml, creditcard, three_d_secure) click to toggle source
# File lib/active_merchant/billing/gateways/orbital.rb, line 494
def add_aav(xml, creditcard, three_d_secure)
  return unless three_d_secure && creditcard.brand == 'master'

  xml.tag!(:AAV, three_d_secure[:cavv])
end
add_address(xml, creditcard, options) click to toggle source
# File lib/active_merchant/billing/gateways/orbital.rb, line 387
def add_address(xml, creditcard, options)
  if(address = (options[:billing_address] || options[:address]))
    avs_supported = AVS_SUPPORTED_COUNTRIES.include?(address[:country].to_s) || empty?(address[:country])

    if avs_supported
      xml.tag! :AVSzip,      byte_limit(format_address_field(address[:zip]), 10)
      xml.tag! :AVSaddress1, byte_limit(format_address_field(address[:address1]), 30)
      xml.tag! :AVSaddress2, byte_limit(format_address_field(address[:address2]), 30)
      xml.tag! :AVScity,     byte_limit(format_address_field(address[:city]), 20)
      xml.tag! :AVSstate,    byte_limit(format_address_field(address[:state]), 2)
      xml.tag! :AVSphoneNum, (address[:phone] ? address[:phone].scan(/\d/).join.to_s[0..13] : nil)
    end

    xml.tag! :AVSname, (creditcard&.name ? creditcard.name[0..29] : nil)
    xml.tag! :AVScountryCode, (avs_supported ? byte_limit(format_address_field(address[:country]), 2) : '')

    # Needs to come after AVScountryCode
    add_destination_address(xml, address) if avs_supported
  end
end
add_aevv(xml, creditcard, three_d_secure) click to toggle source
# File lib/active_merchant/billing/gateways/orbital.rb, line 512
def add_aevv(xml, creditcard, three_d_secure)
  return unless three_d_secure && creditcard.brand == 'american_express'

  xml.tag!(:AEVV, three_d_secure[:cavv])
end
add_bin_merchant_and_terminal(xml, parameters) click to toggle source
# File lib/active_merchant/billing/gateways/orbital.rb, line 799
def add_bin_merchant_and_terminal(xml, parameters)
  xml.tag! :BIN, bin
  xml.tag! :MerchantID, @options[:merchant_id]
  xml.tag! :TerminalID, parameters[:terminal_id] || '001'
end
add_cavv(xml, creditcard, three_d_secure) click to toggle source
# File lib/active_merchant/billing/gateways/orbital.rb, line 488
def add_cavv(xml, creditcard, three_d_secure)
  return unless three_d_secure && creditcard.brand == 'visa'

  xml.tag!(:CAVV, three_d_secure[:cavv])
end
add_creditcard(xml, creditcard, currency=nil) click to toggle source
# File lib/active_merchant/billing/gateways/orbital.rb, line 440
def add_creditcard(xml, creditcard, currency=nil)
  unless creditcard.nil?
    xml.tag! :AccountNum, creditcard.number
    xml.tag! :Exp, expiry_date(creditcard)
  end

  xml.tag! :CurrencyCode, currency_code(currency)
  xml.tag! :CurrencyExponent, currency_exponents(currency)

  # If you are trying to collect a Card Verification Number
  # (CardSecVal) for a Visa or Discover transaction, pass one of these values:
  #   1 Value is Present
  #   2 Value on card but illegible
  #   9 Cardholder states data not available
  # If the transaction is not a Visa or Discover transaction:
  #   Null-fill this attribute OR
  #   Do not submit the attribute at all.
  # - http://download.chasepaymentech.com/docs/orbital/orbital_gateway_xml_specification.pdf
  unless creditcard.nil?
    if creditcard.verification_value?
      if %w( visa discover ).include?(creditcard.brand)
        xml.tag! :CardSecValInd, '1'
      end
      xml.tag! :CardSecVal,  creditcard.verification_value
    end
  end
end
add_customer_address(xml, options) click to toggle source

For Profile requests

# File lib/active_merchant/billing/gateways/orbital.rb, line 425
def add_customer_address(xml, options)
  if(address = (options[:billing_address] || options[:address]))
    avs_supported = AVS_SUPPORTED_COUNTRIES.include?(address[:country].to_s)

    xml.tag! :CustomerAddress1, byte_limit(format_address_field(address[:address1]), 30)
    xml.tag! :CustomerAddress2, byte_limit(format_address_field(address[:address2]), 30)
    xml.tag! :CustomerCity, byte_limit(format_address_field(address[:city]), 20)
    xml.tag! :CustomerState, byte_limit(format_address_field(address[:state]), 2)
    xml.tag! :CustomerZIP, byte_limit(format_address_field(address[:zip]), 10)
    xml.tag! :CustomerEmail, byte_limit(address[:email], 50) if address[:email]
    xml.tag! :CustomerPhone, (address[:phone] ? address[:phone].scan(/\d/).join.to_s : nil)
    xml.tag! :CustomerCountryCode, (avs_supported ? address[:country] : '')
  end
end
add_customer_data(xml, creditcard, options) click to toggle source
# File lib/active_merchant/billing/gateways/orbital.rb, line 325
def add_customer_data(xml, creditcard, options)
  if options[:profile_txn]
    xml.tag! :CustomerRefNum, options[:customer_ref_num]
  else
    if options[:customer_ref_num]
      if creditcard
        xml.tag! :CustomerProfileFromOrderInd, USE_CUSTOMER_REF_NUM
      end
      xml.tag! :CustomerRefNum, options[:customer_ref_num]
    else
      xml.tag! :CustomerProfileFromOrderInd, AUTO_GENERATE
    end
    xml.tag! :CustomerProfileOrderOverrideInd, options[:customer_profile_order_override_ind] || NO_MAPPING_TO_ORDER_DATA
  end
end
add_destination_address(xml, address) click to toggle source
# File lib/active_merchant/billing/gateways/orbital.rb, line 408
def add_destination_address(xml, address)
  if address[:dest_zip]
    avs_supported = AVS_SUPPORTED_COUNTRIES.include?(address[:dest_country].to_s)

    xml.tag! :AVSDestzip,      byte_limit(format_address_field(address[:dest_zip]), 10)
    xml.tag! :AVSDestaddress1, byte_limit(format_address_field(address[:dest_address1]), 30)
    xml.tag! :AVSDestaddress2, byte_limit(format_address_field(address[:dest_address2]), 30)
    xml.tag! :AVSDestcity,     byte_limit(format_address_field(address[:dest_city]), 20)
    xml.tag! :AVSDeststate,    byte_limit(format_address_field(address[:dest_state]), 2)
    xml.tag! :AVSDestphoneNum, (address[:dest_phone] ? address[:dest_phone].scan(/\d/).join.to_s[0..13] : nil)

    xml.tag! :AVSDestname,        byte_limit(address[:dest_name], 30)
    xml.tag! :AVSDestcountryCode, (avs_supported ? address[:dest_country] : '')
  end
end
add_digital_token_cryptogram(xml, creditcard) click to toggle source
# File lib/active_merchant/billing/gateways/orbital.rb, line 506
def add_digital_token_cryptogram(xml, creditcard)
  return unless creditcard.is_a?(NetworkTokenizationCreditCard)

  xml.tag! :DigitalTokenCryptogram, creditcard.payment_cryptogram
end
add_dpanind(xml, creditcard) click to toggle source
# File lib/active_merchant/billing/gateways/orbital.rb, line 500
def add_dpanind(xml, creditcard)
  return unless creditcard.is_a?(NetworkTokenizationCreditCard)

  xml.tag! :DPANInd, 'Y'
end
add_eci(xml, creditcard, three_d_secure) click to toggle source
# File lib/active_merchant/billing/gateways/orbital.rb, line 468
def add_eci(xml, creditcard, three_d_secure)
  eci = if three_d_secure
          three_d_secure[:eci]
        elsif creditcard.is_a?(NetworkTokenizationCreditCard)
          creditcard.eci
        end

  xml.tag!(:AuthenticationECIInd, eci) if eci
end
add_level_2_advice_addendum(xml, options={}) click to toggle source
# File lib/active_merchant/billing/gateways/orbital.rb, line 366
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]
  end
end
add_level_2_purchase(xml, options={}) click to toggle source
# File lib/active_merchant/billing/gateways/orbital.rb, line 375
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]
  end
end
add_level_2_tax(xml, options={}) click to toggle source
# File lib/active_merchant/billing/gateways/orbital.rb, line 359
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]
  end
end
add_managed_billing(xml, options) click to toggle source
# File lib/active_merchant/billing/gateways/orbital.rb, line 531
def add_managed_billing(xml, options)
  if mb = options[:managed_billing]
    ActiveMerchant.deprecated RECURRING_DEPRECATION_MESSAGE

    # default to recurring (R).  Other option is deferred (D).
    xml.tag! :MBType, mb[:type] || RECURRING
    # default to Customer Reference Number
    xml.tag! :MBOrderIdGenerationMethod,     mb[:order_id_generation_method] || 'IO'
    # By default use MBRecurringEndDate, set to N.
    # MMDDYYYY
    xml.tag! :MBRecurringStartDate,          mb[:start_date].scan(/\d/).join.to_s if mb[:start_date]
    # MMDDYYYY
    xml.tag! :MBRecurringEndDate,            mb[:end_date].scan(/\d/).join.to_s if mb[:end_date]
    # By default listen to any value set in MBRecurringEndDate.
    xml.tag! :MBRecurringNoEndDateFlag,      mb[:no_end_date_flag] || 'N' # 'Y' || 'N' (Yes or No).
    xml.tag! :MBRecurringMaxBillings,        mb[:max_billings]       if mb[:max_billings]
    xml.tag! :MBRecurringFrequency,          mb[:frequency]          if mb[:frequency]
    xml.tag! :MBDeferredBillDate,            mb[:deferred_bill_date] if mb[:deferred_bill_date]
    xml.tag! :MBMicroPaymentMaxDollarValue,  mb[:max_dollar_value]   if mb[:max_dollar_value]
    xml.tag! :MBMicroPaymentMaxBillingDays,  mb[:max_billing_days]   if mb[:max_billing_days]
    xml.tag! :MBMicroPaymentMaxTransactions, mb[:max_transactions]   if mb[:max_transactions]
  end
end
add_pymt_brand_program_code(xml, creditcard, three_d_secure) click to toggle source
# File lib/active_merchant/billing/gateways/orbital.rb, line 518
def add_pymt_brand_program_code(xml, creditcard, three_d_secure)
  return unless three_d_secure && creditcard.brand == 'american_express'

  xml.tag!(:PymtBrandProgramCode, 'ASK')
end
add_refund(xml, currency=nil) click to toggle source
# File lib/active_merchant/billing/gateways/orbital.rb, line 524
def add_refund(xml, currency=nil)
  xml.tag! :AccountNum, nil

  xml.tag! :CurrencyCode, currency_code(currency)
  xml.tag! :CurrencyExponent, currency_exponents(currency)
end
add_soft_descriptors(xml, soft_desc) click to toggle source
# File lib/active_merchant/billing/gateways/orbital.rb, line 341
def add_soft_descriptors(xml, soft_desc)
  xml.tag! :SDMerchantName, soft_desc.merchant_name             if soft_desc.merchant_name
  xml.tag! :SDProductDescription, soft_desc.product_description if soft_desc.product_description
  xml.tag! :SDMerchantCity, soft_desc.merchant_city             if soft_desc.merchant_city
  xml.tag! :SDMerchantPhone, soft_desc.merchant_phone           if soft_desc.merchant_phone
  xml.tag! :SDMerchantURL, soft_desc.merchant_url               if soft_desc.merchant_url
  xml.tag! :SDMerchantEmail, soft_desc.merchant_email           if soft_desc.merchant_email
end
add_soft_descriptors_from_hash(xml, soft_desc) click to toggle source
# File lib/active_merchant/billing/gateways/orbital.rb, line 350
def add_soft_descriptors_from_hash(xml, soft_desc)
  xml.tag! :SDMerchantName, soft_desc[:merchant_name] || nil
  xml.tag! :SDProductDescription, soft_desc[:product_description] || nil
  xml.tag! :SDMerchantCity, soft_desc[:merchant_city] || nil
  xml.tag! :SDMerchantPhone, soft_desc[:merchant_phone] || nil
  xml.tag! :SDMerchantURL, soft_desc[:merchant_url] || nil
  xml.tag! :SDMerchantEmail, soft_desc[:merchant_email] || nil
end
add_stored_credentials(xml, parameters) click to toggle source
# File lib/active_merchant/billing/gateways/orbital.rb, line 555
def add_stored_credentials(xml, parameters)
  return unless parameters[:mit_stored_credential_ind] == 'Y' || parameters[:stored_credential] && !parameters[:stored_credential].values.all?(&:nil?)
  if msg_type = get_msg_type(parameters)
    xml.tag! :MITMsgType, msg_type
  end
  xml.tag! :MITStoredCredentialInd, 'Y'
  if parameters[:mit_submitted_transaction_id]
    xml.tag! :MITSubmittedTransactionID, parameters[:mit_submitted_transaction_id]
  elsif parameters.dig(:stored_credential, :network_transaction_id) && parameters.dig(:stored_credential, :initiator) == 'merchant'
    xml.tag! :MITSubmittedTransactionID, parameters[:stored_credential][:network_transaction_id]
  end
end
add_xid(xml, creditcard, three_d_secure) click to toggle source
# File lib/active_merchant/billing/gateways/orbital.rb, line 478
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

  xml.tag!(:XID, xid) if xid
end
add_xml_credentials(xml) click to toggle source
# File lib/active_merchant/billing/gateways/orbital.rb, line 792
def add_xml_credentials(xml)
  unless ip_authentication?
    xml.tag! :OrbitalConnectionUsername, @options[:login]
    xml.tag! :OrbitalConnectionPassword, @options[:password]
  end
end
authorization_string(*args) click to toggle source
# File lib/active_merchant/billing/gateways/orbital.rb, line 317
def authorization_string(*args)
  args.compact.join(';')
end
bin() click to toggle source
# File lib/active_merchant/billing/gateways/orbital.rb, line 782
def bin
  @options[:bin] || (salem_mid? ? '000001' : '000002')
end
build_customer_request_xml(creditcard, options = {}) click to toggle source
# File lib/active_merchant/billing/gateways/orbital.rb, line 841
def build_customer_request_xml(creditcard, options = {})
  ActiveMerchant.deprecated 'Customer Profile support in Orbital is non-conformant to the ActiveMerchant API and will be removed in its current form in a future version. Please contact the ActiveMerchant maintainers if you have an interest in modifying it to conform to the store/unstore/update API.'
  xml = xml_envelope
  xml.tag! :Request do
    xml.tag! :Profile do
      xml.tag! :OrbitalConnectionUsername, @options[:login] unless ip_authentication?
      xml.tag! :OrbitalConnectionPassword, @options[:password] unless ip_authentication?
      xml.tag! :CustomerBin, bin
      xml.tag! :CustomerMerchantID, @options[:merchant_id]
      xml.tag! :CustomerName, creditcard.name if creditcard
      xml.tag! :CustomerRefNum, options[:customer_ref_num] if options[:customer_ref_num]

      add_customer_address(xml, options)

      xml.tag! :CustomerProfileAction, options[:customer_profile_action] # C, R, U, D
      # NO No mapping to order data
      # OI Use <CustomerRefNum> for <OrderID>
      # OD Use <CustomerReferNum> for <Comments>
      # OA Use <CustomerRefNum> for <OrderID> and <Comments>
      xml.tag! :CustomerProfileOrderOverrideInd, options[:customer_profile_order_override_ind] || NO_MAPPING_TO_ORDER_DATA

      if options[:customer_profile_action] == CREATE
        # A Auto-Generate the CustomerRefNum
        # S Use CustomerRefNum field
        # O Use OrderID field
        # D Use Comments field
        xml.tag! :CustomerProfileFromOrderInd, (options[:customer_ref_num] ? USE_CUSTOMER_REF_NUM : AUTO_GENERATE)
      end

      xml.tag! :OrderDefaultDescription, options[:order_default_description][0..63] if options[:order_default_description]
      xml.tag! :OrderDefaultAmount, options[:order_default_amount] if options[:order_default_amount]

      if [CREATE, UPDATE].include? options[:customer_profile_action]
        xml.tag! :CustomerAccountType, 'CC' # Only credit card supported
        xml.tag! :Status, options[:status] || ACTIVE # Active
      end

      xml.tag! :CCAccountNum, creditcard.number if creditcard
      xml.tag! :CCExpireDate, creditcard.expiry_date.expiration.strftime('%m%y') if creditcard

      # This has to come after CCExpireDate.
      add_managed_billing(xml, options)
    end
  end
  xml.target!
end
build_mark_for_capture_xml(money, authorization, parameters = {}) click to toggle source
# File lib/active_merchant/billing/gateways/orbital.rb, line 734
def build_mark_for_capture_xml(money, authorization, parameters = {})
  tx_ref_num, order_id = split_authorization(authorization)
  xml = xml_envelope
  xml.tag! :Request do
    xml.tag! :MarkForCapture do
      add_xml_credentials(xml)
      xml.tag! :OrderID, format_order_id(order_id)
      xml.tag! :Amount, amount(money)
      add_level_2_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)
    end
  end
  xml.target!
end
build_new_order_xml(action, money, creditcard, parameters = {}) { |xml| ... } click to toggle source
# File lib/active_merchant/billing/gateways/orbital.rb, line 659
def build_new_order_xml(action, money, creditcard, parameters = {})
  requires!(parameters, :order_id)
  xml = xml_envelope
  xml.tag! :Request do
    xml.tag! :NewOrder do
      add_xml_credentials(xml)
      # EC - Ecommerce transaction
      # RC - Recurring Payment transaction
      # MO - Mail Order Telephone Order transaction
      # IV - Interactive Voice Response
      # IN - Interactive Voice Response
      xml.tag! :IndustryType, parameters[:industry_type] || ECOMMERCE_TRANSACTION
      # A  - Auth Only No Capture
      # AC - Auth and Capture
      # F  - Force Auth No Capture and no online authorization
      # FR - Force Auth No Capture and no online authorization
      # FC - Force Auth and Capture no online authorization
      # R  - Refund and Capture no online authorization
      xml.tag! :MessageType, action
      add_bin_merchant_and_terminal(xml, parameters)

      yield xml if block_given?

      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)

      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_aav(xml, creditcard, 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

      set_recurring_ind(xml, parameters)

      # Append Transaction Reference Number at the end for Refund transactions
      if action == REFUND
        tx_ref_num, _ = split_authorization(parameters[:authorization])
        xml.tag! :TxRefNum, tx_ref_num
      end

      add_level_2_purchase(xml, parameters)
      add_stored_credentials(xml, parameters)
      add_pymt_brand_program_code(xml, creditcard, three_d_secure)
    end
  end
  xml.target!
end
build_void_request_xml(authorization, parameters = {}) click to toggle source
# File lib/active_merchant/billing/gateways/orbital.rb, line 752
def build_void_request_xml(authorization, parameters = {})
  tx_ref_num, order_id = split_authorization(authorization)
  xml = xml_envelope
  xml.tag! :Request do
    xml.tag! :Reversal do
      add_xml_credentials(xml)
      xml.tag! :TxRefNum, tx_ref_num
      xml.tag! :TxRefIdx, parameters[:transaction_index]
      xml.tag! :AdjustedAmt, parameters[:amount] # setting adjusted amount to nil will void entire amount
      xml.tag! :OrderID, format_order_id(order_id || parameters[:order_id])
      add_bin_merchant_and_terminal(xml, parameters)
      xml.tag! :ReversalRetryNumber, parameters[:reversal_retry_number] if parameters[:reversal_retry_number]
      xml.tag! :OnlineReversalInd,   parameters[:online_reversal_ind]   if parameters[:online_reversal_ind]
    end
  end
  xml.target!
end
byte_limit(value, byte_length) click to toggle source

Field lengths should be limited by byte count instead of character count Returns the truncated value or nil

# File lib/active_merchant/billing/gateways/orbital.rb, line 830
def byte_limit(value, byte_length)
  limited_value = ''

  value.to_s.each_char do |c|
    break if((limited_value.bytesize + c.bytesize) > byte_length)
    limited_value << c
  end

  limited_value
end
commit(order, message_type, trace_number=nil) click to toggle source
# File lib/active_merchant/billing/gateways/orbital.rb, line 607
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
    headers['Merchant-Id'] = @options[:merchant_id]
  end
  request = ->(url) { parse(ssl_post(url, order, headers)) }

  # Failover URL will be attempted in the event of a connection error
  response = begin
    request.call(remote_url)
  rescue ConnectionError
    request.call(remote_url(:secondary))
  end

  Response.new(success?(response, message_type), message_from(response), response,
    {
       :authorization => authorization_string(response[:tx_ref_num], response[:order_id]),
       :test => self.test?,
       :avs_result => OrbitalGateway::AVSResult.new(response[:avs_resp_code]),
       :cvv_result => OrbitalGateway::CVVResult.new(response[:cvv2_resp_code])
    }
  )
end
currency_code(currency) click to toggle source
# File lib/active_merchant/billing/gateways/orbital.rb, line 770
def currency_code(currency)
  CURRENCY_CODES[(currency || self.default_currency)].to_s
end
currency_exponents(currency) click to toggle source
# File lib/active_merchant/billing/gateways/orbital.rb, line 774
def currency_exponents(currency)
  CURRENCY_EXPONENTS[(currency || self.default_currency)].to_s
end
expiry_date(credit_card) click to toggle source
# File lib/active_merchant/billing/gateways/orbital.rb, line 778
def expiry_date(credit_card)
  "#{format(credit_card.month, :two_digits)}#{format(credit_card.year, :two_digits)}"
end
format_address_field(value) click to toggle source

Address-related fields cannot contain % | ^ \ / Returns the value with these characters removed, or nil

# File lib/active_merchant/billing/gateways/orbital.rb, line 824
def format_address_field(value)
  value.gsub(/[%\|\^\\\/]/, '') if value.respond_to?(:gsub)
end
format_order_id(order_id) click to toggle source

The valid characters include:

  1. all letters and digits

    • , $ @ & and a space character, though the space character cannot be the leading character

  2. PINless Debit transactions can only use uppercase and lowercase alpha (A-Z, a-z) and numeric (0-9)

# File lib/active_merchant/billing/gateways/orbital.rb, line 814
def format_order_id(order_id)
  illegal_characters = /[^,$@&\- \w]/
  order_id = order_id.to_s.gsub(/\./, '-')
  order_id.gsub!(illegal_characters, '')
  order_id.lstrip!
  order_id[0...22]
end
get_msg_type(parameters) click to toggle source
# File lib/active_merchant/billing/gateways/orbital.rb, line 568
def get_msg_type(parameters)
  return parameters[:mit_msg_type] if parameters[:mit_msg_type]
  return 'CSTO' if parameters[:stored_credential][:initial_transaction]
  return unless parameters[:stored_credential][:initiator] && parameters[:stored_credential][:reason_type]
  initiator = case parameters[:stored_credential][:initiator]
  when 'customer' then 'C'
  when 'merchant' then 'M'
  end
  reason = case parameters[:stored_credential][:reason_type]
  when 'recurring' then 'REC'
  when 'installment' then 'INS'
  when 'unscheduled' then 'USE'
  end

  "#{initiator}#{reason}"
end
ip_authentication?() click to toggle source
# File lib/active_merchant/billing/gateways/orbital.rb, line 655
def ip_authentication?
  @options[:ip_authentication] == true
end
message_from(response) click to toggle source
# File lib/active_merchant/billing/gateways/orbital.rb, line 651
def message_from(response)
  response[:resp_msg] || response[:status_msg] || response[:customer_profile_message]
end
parse(body) click to toggle source
# File lib/active_merchant/billing/gateways/orbital.rb, line 585
def parse(body)
  response = {}
  xml = REXML::Document.new(body)
  root = REXML::XPath.first(xml, '//Response') ||
         REXML::XPath.first(xml, '//ErrorResponse')
  if root
    root.elements.to_a.each do |node|
      recurring_parse_element(response, node)
    end
  end

  response.delete_if { |k, _| SENSITIVE_FIELDS.include?(k) }
end
recurring_parse_element(response, node) click to toggle source
# File lib/active_merchant/billing/gateways/orbital.rb, line 599
def recurring_parse_element(response, node)
  if node.has_elements?
    node.elements.each { |e| recurring_parse_element(response, e) }
  else
    response[node.name.underscore.to_sym] = node.text
  end
end
remote_url(url=:primary) click to toggle source
# File lib/active_merchant/billing/gateways/orbital.rb, line 632
def remote_url(url=:primary)
  if url == :primary
    (self.test? ? self.test_url : self.live_url)
  else
    (self.test? ? self.secondary_test_url : self.secondary_live_url)
  end
end
salem_mid?() click to toggle source
# File lib/active_merchant/billing/gateways/orbital.rb, line 805
def salem_mid?
  @options[:merchant_id].length == 6
end
set_recurring_ind(xml, parameters) click to toggle source

For Canadian transactions on PNS Tampa on New Order RF - First Recurring Transaction RS - Subsequent Recurring Transactions

# File lib/active_merchant/billing/gateways/orbital.rb, line 727
def set_recurring_ind(xml, parameters)
  if parameters[:recurring_ind]
    raise 'RecurringInd must be set to either "RF" or "RS"' unless %w(RF RS).include?(parameters[:recurring_ind])
    xml.tag! :RecurringInd, parameters[:recurring_ind]
  end
end
split_authorization(authorization) click to toggle source
# File lib/active_merchant/billing/gateways/orbital.rb, line 321
def split_authorization(authorization)
  authorization.split(';')
end
success?(response, message_type) click to toggle source
# File lib/active_merchant/billing/gateways/orbital.rb, line 640
def success?(response, message_type)
  if [:refund, :void].include?(message_type)
    response[:proc_status] == SUCCESS
  elsif response[:customer_profile_action]
    response[:profile_proc_status] == SUCCESS
  else
    response[:proc_status] == SUCCESS &&
    APPROVED.include?(response[:resp_code])
  end
end
xml_envelope() click to toggle source
# File lib/active_merchant/billing/gateways/orbital.rb, line 786
def xml_envelope
  xml = Builder::XmlMarkup.new(:indent => 2)
  xml.instruct!(:xml, :version => '1.0', :encoding => 'UTF-8')
  xml
end