archetype2142_activemerchant 1.124.0

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

@@ -0,0 +1,409 @@
+require 'nokogiri'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class PayexGateway < Gateway
+      class_attribute :live_external_url, :test_external_url, :live_confined_url, :test_confined_url
+
+      self.live_external_url = 'https://external.payex.com/'
+      self.test_external_url = 'https://test-external.payex.com/'
+
+      self.live_confined_url = 'https://confined.payex.com/'
+      self.test_confined_url = 'https://test-confined.payex.com/'
+
+      self.money_format = :cents
+      self.supported_countries = %w[DK FI NO SE]
+      self.supported_cardtypes = %i[visa master american_express discover]
+      self.homepage_url = 'http://payex.com/'
+      self.display_name = 'Payex'
+      self.default_currency = 'EUR'
+
+      TRANSACTION_STATUS = {
+        sale:       '0',
+        initialize: '1',
+        credit:     '2',
+        authorize:  '3',
+        cancel:     '4',
+        failure:    '5',
+        capture:    '6'
+      }
+
+      SOAP_ACTIONS = {
+        initialize: { name: 'Initialize8', url: 'pxorder/pxorder.asmx', xmlns: 'http://external.payex.com/PxOrder/' },
+        purchasecc: { name: 'PurchaseCC', url: 'pxconfined/pxorder.asmx', xmlns: 'http://confined.payex.com/PxOrder/', confined: true },
+        cancel: { name: 'Cancel2', url: 'pxorder/pxorder.asmx', xmlns: 'http://external.payex.com/PxOrder/' },
+        capture: { name: 'Capture5', url: 'pxorder/pxorder.asmx', xmlns: 'http://external.payex.com/PxOrder/' },
+        credit: { name: 'Credit5', url: 'pxorder/pxorder.asmx', xmlns: 'http://external.payex.com/PxOrder/' },
+        create_agreement: { name: 'CreateAgreement3', url: 'pxagreement/pxagreement.asmx', xmlns: 'http://external.payex.com/PxAgreement/' },
+        delete_agreement: { name: 'DeleteAgreement', url: 'pxagreement/pxagreement.asmx', xmlns: 'http://external.payex.com/PxAgreement/' },
+        autopay: { name: 'AutoPay3', url: 'pxagreement/pxagreement.asmx', xmlns: 'http://external.payex.com/PxAgreement/' }
+      }
+
+      def initialize(options = {})
+        requires!(options, :account, :encryption_key)
+        super
+      end
+
+      # Public: Send an authorize Payex request
+      #
+      # amount         - The monetary amount of the transaction in cents.
+      # payment_method - The Active Merchant payment method or the +store+ authorization for stored transactions.
+      # options        - A standard ActiveMerchant options hash:
+      #                  :currency          - Three letter currency code for the transaction (default: "EUR")
+      #                  :order_id          - The unique order ID for this transaction (required).
+      #                  :product_number    - The merchant product number (default: '1').
+      #                  :description       - The merchant description for this product (default: The :order_id).
+      #                  :ip                - The client IP address (default: '127.0.0.1').
+      #                  :vat               - The vat amount (optional).
+      #
+      # Returns an ActiveMerchant::Billing::Response object
+      def authorize(amount, payment_method, options = {})
+        requires!(options, :order_id)
+        amount = amount(amount)
+        if payment_method.respond_to?(:number)
+          # credit card authorization
+          MultiResponse.new.tap do |r|
+            r.process { send_initialize(amount, true, options) }
+            r.process { send_purchasecc(payment_method, r.params['orderref']) }
+          end
+        else
+          # stored authorization
+          send_autopay(amount, payment_method, true, options)
+        end
+      end
+
+      # Public: Send a purchase Payex request
+      #
+      # amount         - The monetary amount of the transaction in cents.
+      # payment_method - The Active Merchant payment method or the +store+ authorization for stored transactions.
+      # options        - A standard ActiveMerchant options hash:
+      #                  :currency          - Three letter currency code for the transaction (default: "EUR")
+      #                  :order_id          - The unique order ID for this transaction (required).
+      #                  :product_number    - The merchant product number (default: '1').
+      #                  :description       - The merchant description for this product (default: The :order_id).
+      #                  :ip                - The client IP address (default: '127.0.0.1').
+      #                  :vat               - The vat amount (optional).
+      #
+      # Returns an ActiveMerchant::Billing::Response object
+      def purchase(amount, payment_method, options = {})
+        requires!(options, :order_id)
+        amount = amount(amount)
+        if payment_method.respond_to?(:number)
+          # credit card purchase
+          MultiResponse.new.tap do |r|
+            r.process { send_initialize(amount, false, options) }
+            r.process { send_purchasecc(payment_method, r.params['orderref']) }
+          end
+        else
+          # stored purchase
+          send_autopay(amount, payment_method, false, options)
+        end
+      end
+
+      # Public: Capture money from a previously authorized transaction
+      #
+      # money - The amount to capture
+      # authorization - The authorization token from the authorization request
+      #
+      # Returns an ActiveMerchant::Billing::Response object
+      def capture(money, authorization, options = {})
+        amount = amount(money)
+        send_capture(amount, authorization)
+      end
+
+      # Public: Voids an authorize transaction
+      #
+      # authorization - The authorization returned from the successful authorize transaction.
+      # options        - A standard ActiveMerchant options hash
+      #
+      # Returns an ActiveMerchant::Billing::Response object
+      def void(authorization, options = {})
+        send_cancel(authorization)
+      end
+
+      # Public: Refunds a purchase transaction
+      #
+      # money - The amount to refund
+      # authorization - The authorization token from the purchase request.
+      # options        - A standard ActiveMerchant options hash:
+      #                  :order_id          - The unique order ID for this transaction (required).
+      #                  :vat_amount        - The vat amount (optional).
+      #
+      # Returns an ActiveMerchant::Billing::Response object
+      def refund(money, authorization, options = {})
+        requires!(options, :order_id)
+        amount = amount(money)
+        send_credit(authorization, amount, options)
+      end
+
+      # Public: Stores a credit card and creates a Payex agreement with a customer
+      #
+      # creditcard - The credit card to store.
+      # options    - A standard ActiveMerchant options hash:
+      #               :order_id          - The unique order ID for this transaction (required).
+      #               :merchant_ref      - A reference that links this agreement to something the merchant takes money for (default: '1')
+      #               :currency          - Three letter currency code for the transaction (default: "EUR")
+      #               :product_number    - The merchant product number (default: '1').
+      #               :description       - The merchant description for this product (default: The :order_id).
+      #               :ip                - The client IP address (default: '127.0.0.1').
+      #               :max_amount        - The maximum amount to allow to be charged (default: 100000).
+      #               :vat               - The vat amount (optional).
+      #
+      # Returns an ActiveMerchant::Billing::Response object where the authorization is set to the agreement_ref which is used for stored payments.
+      def store(creditcard, options = {})
+        requires!(options, :order_id)
+        amount = amount(1) # 1 cent for authorization
+        MultiResponse.run(:first) do |r|
+          r.process { send_create_agreement(options) }
+          r.process { send_initialize(amount, true, options.merge({ agreement_ref: r.authorization })) }
+          order_ref = r.params['orderref']
+          r.process { send_purchasecc(creditcard, order_ref) }
+        end
+      end
+
+      # Public: Unstores a customer's credit card and deletes their Payex agreement.
+      #
+      # authorization - The authorization token from the store request.
+      #
+      # Returns an ActiveMerchant::Billing::Response object
+      def unstore(authorization, options = {})
+        send_delete_agreement(authorization)
+      end
+
+      private
+
+      def send_initialize(amount, is_auth, options = {})
+        properties = {
+          accountNumber: @options[:account],
+          purchaseOperation: is_auth ? 'AUTHORIZATION' : 'SALE',
+          price: amount,
+          priceArgList: nil,
+          currency: (options[:currency] || default_currency),
+          vat: options[:vat] || 0,
+          orderID: options[:order_id],
+          productNumber: options[:product_number] || '1',
+          description: options[:description] || options[:order_id],
+          clientIPAddress: options[:client_ip_address] || '127.0.0.1',
+          clientIdentifier: nil,
+          additionalValues: nil,
+          externalID: nil,
+          returnUrl: 'http://example.net', # set to dummy value since this is not used but is required
+          view: 'CREDITCARD',
+          agreementRef: options[:agreement_ref], # this is used to attach a stored agreement to a transaction as part of the store card
+          cancelUrl: nil,
+          clientLanguage: nil
+        }
+        hash_fields = %i[accountNumber purchaseOperation price priceArgList currency vat orderID
+                         productNumber description clientIPAddress clientIdentifier additionalValues
+                         externalID returnUrl view agreementRef cancelUrl clientLanguage]
+        add_request_hash(properties, hash_fields)
+        soap_action = SOAP_ACTIONS[:initialize]
+        request = build_xml_request(soap_action, properties)
+        commit(soap_action, request)
+      end
+
+      def send_purchasecc(payment_method, order_ref)
+        properties = {
+          accountNumber: @options[:account],
+          orderRef: order_ref,
+          transactionType: 1, # online payment
+          cardNumber: payment_method.number,
+          cardNumberExpireMonth: format(payment_method.month, :two_digits),
+          cardNumberExpireYear: format(payment_method.year, :two_digits),
+          cardHolderName: payment_method.name,
+          cardNumberCVC: payment_method.verification_value
+        }
+        hash_fields = %i[accountNumber orderRef transactionType cardNumber cardNumberExpireMonth
+                         cardNumberExpireYear cardNumberCVC cardHolderName]
+        add_request_hash(properties, hash_fields)
+
+        soap_action = SOAP_ACTIONS[:purchasecc]
+        request = build_xml_request(soap_action, properties)
+        commit(soap_action, request)
+      end
+
+      def send_autopay(amount, authorization, is_auth, options = {})
+        properties = {
+          accountNumber: @options[:account],
+          agreementRef: authorization,
+          price: amount,
+          productNumber: options[:product_number] || '1',
+          description: options[:description] || options[:order_id],
+          orderId: options[:order_id],
+          purchaseOperation: is_auth ? 'AUTHORIZATION' : 'SALE',
+          currency: (options[:currency] || default_currency)
+        }
+        hash_fields = %i[accountNumber agreementRef price productNumber description orderId purchaseOperation currency]
+        add_request_hash(properties, hash_fields)
+
+        soap_action = SOAP_ACTIONS[:autopay]
+        request = build_xml_request(soap_action, properties)
+        commit(soap_action, request)
+      end
+
+      def send_capture(amount, transaction_number, options = {})
+        properties = {
+          accountNumber: @options[:account],
+          transactionNumber: transaction_number,
+          amount: amount,
+          orderId: options[:order_id] || '',
+          vatAmount: options[:vat_amount] || 0,
+          additionalValues: ''
+        }
+        hash_fields = %i[accountNumber transactionNumber amount orderId vatAmount additionalValues]
+        add_request_hash(properties, hash_fields)
+
+        soap_action = SOAP_ACTIONS[:capture]
+        request = build_xml_request(soap_action, properties)
+        commit(soap_action, request)
+      end
+
+      def send_credit(transaction_number, amount, options = {})
+        properties = {
+          accountNumber: @options[:account],
+          transactionNumber: transaction_number,
+          amount: amount,
+          orderId: options[:order_id],
+          vatAmount: options[:vat_amount] || 0,
+          additionalValues: ''
+        }
+        hash_fields = %i[accountNumber transactionNumber amount orderId vatAmount additionalValues]
+        add_request_hash(properties, hash_fields)
+
+        soap_action = SOAP_ACTIONS[:credit]
+        request = build_xml_request(soap_action, properties)
+        commit(soap_action, request)
+      end
+
+      def send_cancel(transaction_number)
+        properties = {
+          accountNumber: @options[:account],
+          transactionNumber: transaction_number
+        }
+        hash_fields = %i[accountNumber transactionNumber]
+        add_request_hash(properties, hash_fields)
+
+        soap_action = SOAP_ACTIONS[:cancel]
+        request = build_xml_request(soap_action, properties)
+        commit(soap_action, request)
+      end
+
+      def send_create_agreement(options)
+        properties = {
+          accountNumber: @options[:account],
+          merchantRef: options[:merchant_ref] || '1',
+          description: options[:description] || options[:order_id],
+          purchaseOperation: 'SALE',
+          maxAmount: options[:max_amount] || 100000, # default to 1,000
+          notifyUrl: '',
+          startDate: options[:startDate] || '',
+          stopDate: options[:stopDate] || ''
+        }
+        hash_fields = %i[accountNumber merchantRef description purchaseOperation maxAmount notifyUrl startDate stopDate]
+        add_request_hash(properties, hash_fields)
+
+        soap_action = SOAP_ACTIONS[:create_agreement]
+        request = build_xml_request(soap_action, properties)
+        commit(soap_action, request)
+      end
+
+      def send_delete_agreement(authorization)
+        properties = {
+          accountNumber: @options[:account],
+          agreementRef: authorization
+        }
+        hash_fields = %i[accountNumber agreementRef]
+        add_request_hash(properties, hash_fields)
+
+        soap_action = SOAP_ACTIONS[:delete_agreement]
+        request = build_xml_request(soap_action, properties)
+        commit(soap_action, request)
+      end
+
+      def url_for(soap_action)
+        File.join(base_url(soap_action), soap_action[:url])
+      end
+
+      def base_url(soap_action)
+        if soap_action[:confined]
+          test? ? test_confined_url : live_confined_url
+        else
+          test? ? test_external_url : live_external_url
+        end
+      end
+
+      # this will add a hash to the passed in properties as required by Payex requests
+      def add_request_hash(properties, fields)
+        data = fields.map { |e| properties[e] }
+        data << @options[:encryption_key]
+        properties['hash_'] = Digest::MD5.hexdigest(data.join(''))
+      end
+
+      def build_xml_request(soap_action, properties)
+        builder = Nokogiri::XML::Builder.new
+        builder.__send__('soap12:Envelope', { 'xmlns:xsi' => 'http://www.w3.org/2001/XMLSchema-instance',
+                                             'xmlns:xsd' => 'http://www.w3.org/2001/XMLSchema',
+                                             'xmlns:soap12' => 'http://www.w3.org/2003/05/soap-envelope' }) do |root|
+          root.__send__('soap12:Body') do |body|
+            body.__send__(soap_action[:name], xmlns: soap_action[:xmlns]) do |doc|
+              properties.each do |key, val|
+                doc.send(key, val)
+              end
+            end
+          end
+        end
+        builder.to_xml
+      end
+
+      def parse(xml)
+        response = {}
+
+        xmldoc = Nokogiri::XML(xml)
+        body = xmldoc.xpath('//soap:Body/*[1]')[0].inner_text
+
+        doc = Nokogiri::XML(body)
+
+        doc.root&.xpath('*')&.each do |node|
+          if node.elements.size == 0
+            response[node.name.downcase.to_sym] = node.text
+          else
+            node.elements.each do |childnode|
+              name = "#{node.name.downcase}_#{childnode.name.downcase}"
+              response[name.to_sym] = childnode.text
+            end
+          end
+        end
+
+        response
+      end
+
+      # Commits all requests to the Payex soap endpoint
+      def commit(soap_action, request)
+        url = url_for(soap_action)
+        headers = {
+          'Content-Type' => 'application/soap+xml; charset=utf-8',
+          'Content-Length' => request.size.to_s
+        }
+        response = parse(ssl_post(url, request, headers))
+        Response.new(success?(response),
+          message_from(response),
+          response,
+          test: test?,
+          authorization: build_authorization(response))
+      end
+
+      def build_authorization(response)
+        # agreementref is for the store transaction, everything else gets transactionnumber
+        response[:transactionnumber] || response[:agreementref]
+      end
+
+      def success?(response)
+        response[:status_errorcode] == 'OK' && response[:transactionstatus] != TRANSACTION_STATUS[:failure]
+      end
+
+      def message_from(response)
+        response[:status_description]
+      end
+    end
+  end
+end

data/lib/active_merchant/billing/gateways/payflow/payflow_common_api.rb

@@ -0,0 +1,235 @@
+require 'nokogiri'
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    module PayflowCommonAPI
+      def self.included(base)
+        base.default_currency = 'USD'
+
+        base.class_attribute :partner
+
+        # Set the default partner to PayPal
+        base.partner = 'PayPal'
+
+        base.supported_countries = %w[US CA NZ AU]
+
+        base.class_attribute :timeout
+        base.timeout = 60
+
+        base.test_url = 'https://pilot-payflowpro.paypal.com'
+        base.live_url = 'https://payflowpro.paypal.com'
+
+        # Enable safe retry of failed connections
+        # Payflow is safe to retry because retried transactions use the same
+        # X-VPS-Request-ID header. If a transaction is detected as a duplicate
+        # only the original transaction data will be used by Payflow, and the
+        # subsequent Responses will have a :duplicate parameter set in the params
+        # hash.
+        base.retry_safe = true
+
+        # Send Payflow requests to PayPal directly by activating the NVP protocol.
+        # Valid XMLPay documents may have issues being parsed correctly by
+        # Payflow but will be accepted by PayPal if a PAYPAL-NVP request header
+        # is declared.
+        base.class_attribute :use_paypal_nvp
+        base.use_paypal_nvp = false
+      end
+
+      XMLNS = 'http://www.paypal.com/XMLPay'
+
+      CARD_MAPPING = {
+        visa: 'Visa',
+        master: 'MasterCard',
+        discover: 'Discover',
+        american_express: 'Amex',
+        jcb: 'JCB',
+        diners_club: 'DinersClub'
+      }
+
+      TRANSACTIONS = {
+        purchase: 'Sale',
+        authorization: 'Authorization',
+        capture: 'Capture',
+        void: 'Void',
+        credit: 'Credit'
+      }
+
+      CVV_CODE = {
+        'Match' => 'M',
+        'No Match' => 'N',
+        'Service Not Available' => 'U',
+        'Service not Requested' => 'P'
+      }
+
+      def initialize(options = {})
+        requires!(options, :login, :password)
+
+        options[:partner] = partner if options[:partner].blank?
+        super
+      end
+
+      def capture(money, authorization, options = {})
+        request = build_reference_request(:capture, money, authorization, options)
+        commit(request, options)
+      end
+
+      def void(authorization, options = {})
+        request = build_reference_request(:void, nil, authorization, options)
+        commit(request, options)
+      end
+
+      private
+
+      def build_request(body, options = {})
+        xml = Builder::XmlMarkup.new
+        xml.instruct!
+        xml.tag! 'XMLPayRequest', 'Timeout' => timeout.to_s, 'version' => '2.1', 'xmlns' => XMLNS do
+          xml.tag! 'RequestData' do
+            xml.tag! 'Vendor', @options[:login]
+            xml.tag! 'Partner', @options[:partner]
+            if options[:request_type] == :recurring
+              xml << body
+            else
+              xml.tag! 'Transactions' do
+                xml.tag! 'Transaction', 'CustRef' => options[:customer] do
+                  xml.tag! 'Verbosity', @options[:verbosity] || 'MEDIUM'
+                  xml << body
+                end
+              end
+            end
+          end
+          xml.tag! 'RequestAuth' do
+            xml.tag! 'UserPass' do
+              xml.tag! 'User', !@options[:user].blank? ? @options[:user] : @options[:login]
+              xml.tag! 'Password', @options[:password]
+            end
+          end
+        end
+        xml.target!
+      end
+
+      def build_reference_request(action, money, authorization, options)
+        xml = Builder::XmlMarkup.new
+        xml.tag! TRANSACTIONS[action] do
+          xml.tag! 'PNRef', authorization
+
+          unless money.nil?
+            xml.tag! 'Invoice' do
+              xml.tag!('TotalAmt', amount(money), 'Currency' => options[:currency] || currency(money))
+              xml.tag!('Description', options[:description]) unless options[:description].blank?
+              xml.tag!('Comment', options[:comment]) unless options[:comment].blank?
+              xml.tag!('ExtData', 'Name' => 'COMMENT2', 'Value' => options[:comment2]) unless options[:comment2].blank?
+              xml.tag!('MerchDescr', options[:merch_descr]) unless options[:merch_descr].blank?
+              xml.tag!(
+                'ExtData',
+                'Name' => 'CAPTURECOMPLETE',
+                'Value' => options[:capture_complete]
+              ) unless options[:capture_complete].blank?
+            end
+          end
+        end
+
+        xml.target!
+      end
+
+      def add_address(xml, tag, address, options)
+        return if address.nil?
+
+        xml.tag! tag do
+          xml.tag! 'Name', address[:name] unless address[:name].blank?
+          xml.tag! 'EMail', options[:email] unless options[:email].blank?
+          xml.tag! 'Phone', address[:phone] unless address[:phone].blank?
+          xml.tag! 'CustCode', options[:customer] if !options[:customer].blank? && tag == 'BillTo'
+          xml.tag! 'PONum', options[:po_number] if !options[:po_number].blank? && tag == 'BillTo'
+
+          xml.tag! 'Address' do
+            xml.tag! 'Street', address[:address1] unless address[:address1].blank?
+            xml.tag! 'Street2', address[:address2] unless address[:address2].blank?
+            xml.tag! 'City', address[:city] unless address[:city].blank?
+            xml.tag! 'State', address[:state].blank? ? 'N/A' : address[:state]
+            xml.tag! 'Country', address[:country] unless address[:country].blank?
+            xml.tag! 'Zip', address[:zip] unless address[:zip].blank?
+          end
+        end
+      end
+
+      def parse(data)
+        response = {}
+        xml = Nokogiri::XML(data)
+        xml.remove_namespaces!
+        root = xml.xpath('//ResponseData')
+
+        # REXML::XPath in Ruby 1.8.6 is now unable to match nodes based on their attributes
+        tx_result = root.xpath('.//TransactionResult').first
+
+        response[:duplicate] = true if tx_result && tx_result.attributes['Duplicate'].to_s == 'true'
+
+        root.xpath('.//*').each do |node|
+          parse_element(response, node)
+        end
+
+        response
+      end
+
+      def parse_element(response, node)
+        node_name = node.name.underscore.to_sym
+        case
+        when node_name == :rp_payment_result
+          # Since we'll have multiple history items, we can't just flatten everything
+          # down as we do everywhere else. RPPaymentResult elements are not contained
+          # in an RPPaymentResults element so we'll come here multiple times
+          response[node_name] ||= []
+          response[node_name] << (payment_result_response = {})
+          node.xpath('.//*').each { |e| parse_element(payment_result_response, e) }
+        when node.xpath('.//*').to_a.any?
+          node.xpath('.//*').each { |e| parse_element(response, e) }
+        when /amt$/.match?(node_name.to_s)
+          # *Amt elements don't put the value in the #text - instead they use a Currency attribute
+          response[node_name] = node.attributes['Currency'].to_s
+        when node_name == :ext_data
+          response[node.attributes['Name'].to_s.underscore.to_sym] = node.attributes['Value'].to_s
+        else
+          response[node_name] = node.text
+        end
+      end
+
+      def build_headers(content_length)
+        headers = {
+          'Content-Type' => 'text/xml',
+          'Content-Length' => content_length.to_s,
+          'X-VPS-Client-Timeout' => timeout.to_s,
+          'X-VPS-VIT-Integration-Product' => 'ActiveMerchant',
+          'X-VPS-VIT-Runtime-Version' => RUBY_VERSION,
+          'X-VPS-Request-ID' => SecureRandom.hex(16)
+        }
+
+        headers['PAYPAL-NVP'] = 'Y' if self.use_paypal_nvp
+        headers
+      end
+
+      def commit(request_body, options = {})
+        request = build_request(request_body, options)
+        headers = build_headers(request.size)
+
+        response = parse(ssl_post(test? ? self.test_url : self.live_url, request, headers))
+
+        build_response(
+          success_for(response),
+          response[:message], response,
+          test: test?,
+          authorization: response[:pn_ref] || response[:rp_ref],
+          cvv_result: CVV_CODE[response[:cv_result]],
+          avs_result: { code: response[:avs_result] },
+          fraud_review: under_fraud_review?(response)
+        )
+      end
+
+      def success_for(response)
+        %w(0 126).include?(response[:result])
+      end
+
+      def under_fraud_review?(response)
+        (response[:result] == '126')
+      end
+    end
+  end
+end

data/lib/active_merchant/billing/gateways/payflow/payflow_express_response.rb

@@ -0,0 +1,42 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class PayflowExpressResponse < Response
+      def email
+        @params['e_mail']
+      end
+
+      def full_name
+        "#{@params['name']} #{@params['lastname']}"
+      end
+
+      def token
+        @params['token']
+      end
+
+      def payer_id
+        @params['payer_id']
+      end
+
+      # Really the shipping country, but it is all the information provided
+      def payer_country
+        address['country']
+      end
+
+      def phone
+        @params['phone']
+      end
+
+      def address
+        {  'name'       => @params['shiptoname'] || full_name,
+           'company'    => nil,
+           'address1'   => @params['street'],
+           'address2'   => @params['shiptostreet2'] || @params['street2'],
+           'city'       => @params['city'],
+           'state'      => @params['state'],
+           'country'    => @params['country'],
+           'zip'        => @params['zip'],
+           'phone'      => phone }
+      end
+    end
+  end
+end