activemerchant-kiddy 1.15.0.kiddy

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

@@ -0,0 +1,235 @@
+require 'rexml/document'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    
+    # In NZ DPS supports ANZ, Westpac, National Bank, ASB and BNZ. 
+    # In Australia DPS supports ANZ, NAB, Westpac, CBA, St George and Bank of South Australia. 
+    # The Maybank in Malaysia is supported and the Citibank for Singapore.
+    class PaymentExpressGateway < Gateway
+      self.default_currency = 'NZD'
+      # PS supports all major credit cards; Visa, Mastercard, Amex, Diners, BankCard & JCB. 
+      # Various white label cards can be accepted as well; Farmers, AirNZCard and Elders etc. 
+      # Please note that not all acquirers and Eftpos networks can support some of these card types.
+      # VISA, Mastercard, Diners Club and Farmers cards are supported
+      #
+      # However, regular accounts with DPS only support VISA and Mastercard
+      self.supported_cardtypes = [ :visa, :master, :american_express, :diners_club, :jcb ]
+      
+      self.supported_countries = [ 'AU', 'MY', 'NZ', 'SG', 'ZA', 'GB', 'US' ]
+      
+      self.homepage_url = 'http://www.paymentexpress.com/'
+      self.display_name = 'PaymentExpress'
+      
+      URL = 'https://www.paymentexpress.com/pxpost.aspx'
+      
+      APPROVED = '1'
+      
+      TRANSACTIONS = {
+        :purchase       => 'Purchase',
+        :credit         => 'Refund',
+        :authorization  => 'Auth',
+        :capture        => 'Complete',
+        :validate       => 'Validate'
+      }
+      
+      # We require the DPS gateway username and password when the object is created.
+      def initialize(options = {})
+        # A DPS username and password must exist 
+        requires!(options, :login, :password)
+        # Make the options an instance variable
+        @options = options
+        super
+      end
+      
+      # Funds are transferred immediately.
+      def purchase(money, payment_source, options = {})
+        request = build_purchase_or_authorization_request(money, payment_source, options)
+        commit(:purchase, request)      
+      end
+      
+      # NOTE: Perhaps in options we allow a transaction note to be inserted
+      # Verifies that funds are available for the requested card and amount and reserves the specified amount.
+      # See: http://www.paymentexpress.com/technical_resources/ecommerce_nonhosted/pxpost.html#Authcomplete
+      def authorize(money, payment_source, options = {})
+        request = build_purchase_or_authorization_request(money, payment_source, options)
+        commit(:authorization, request)
+      end
+      
+      # Transfer pre-authorized funds immediately
+      # See: http://www.paymentexpress.com/technical_resources/ecommerce_nonhosted/pxpost.html#Authcomplete
+      def capture(money, identification, options = {})
+        request = build_capture_or_credit_request(money, identification, options)                                            
+        commit(:capture, request)
+      end
+      
+      # Refund funds to the card holder
+      def refund(money, identification, options = {})
+        requires!(options, :description)
+        
+        request = build_capture_or_credit_request(money, identification, options)                                            
+        commit(:credit, request)
+      end
+
+      def credit(money, identification, options = {})
+        deprecated CREDIT_DEPRECATION_MESSAGE
+        refund(money, identification, options)
+      end
+      
+      # token based billing
+      
+      # initiates a "Validate" transcation to store card data on payment express servers
+      # returns a "token" that can be used to rebill this card
+      # see: http://www.paymentexpress.com/technical_resources/ecommerce_nonhosted/pxpost.html#Tokenbilling
+      # PaymentExpress does not support unstoring a stored card.
+      def store(credit_card, options = {})
+        request  = build_token_request(credit_card, options)
+        commit(:validate, request)
+      end
+      
+      private
+      
+      def build_purchase_or_authorization_request(money, payment_source, options)
+        result = new_transaction      
+
+        if payment_source.is_a?(String)
+          add_billing_token(result, payment_source)
+        else
+          add_credit_card(result, payment_source)
+        end
+        
+        add_amount(result, money, options)
+        add_invoice(result, options)
+        add_address_verification_data(result, options)
+        result
+      end
+      
+      def build_capture_or_credit_request(money, identification, options)
+        result = new_transaction
+      
+        add_amount(result, money, options)
+        add_invoice(result, options)
+        add_reference(result, identification)
+        result
+      end
+      
+      def build_token_request(credit_card, options)
+        result = new_transaction
+        add_credit_card(result, credit_card)
+        add_amount(result, 100, options) #need to make an auth request for $1
+        add_token_request(result, options)
+        result
+      end
+      
+      def add_credentials(xml)
+        xml.add_element("PostUsername").text = @options[:login]
+        xml.add_element("PostPassword").text = @options[:password]
+      end
+      
+      def add_reference(xml, identification)
+        xml.add_element("DpsTxnRef").text = identification
+      end
+      
+      def add_credit_card(xml, credit_card)
+        xml.add_element("CardHolderName").text = credit_card.name
+        xml.add_element("CardNumber").text = credit_card.number
+        xml.add_element("DateExpiry").text = format_date(credit_card.month, credit_card.year)
+        
+        if credit_card.verification_value?
+          xml.add_element("Cvc2").text = credit_card.verification_value
+        end
+        
+        if requires_start_date_or_issue_number?(credit_card)
+          xml.add_element("DateStart").text = format_date(credit_card.start_month, credit_card.start_year) unless credit_card.start_month.blank? || credit_card.start_year.blank?
+          xml.add_element("IssueNumber").text = credit_card.issue_number unless credit_card.issue_number.blank?
+        end
+      end
+      
+      def add_billing_token(xml, token) 
+        xml.add_element("DpsBillingId").text = token
+      end
+      
+      def add_token_request(xml, options)
+        xml.add_element("BillingId").text = options[:billing_id] if options[:billing_id]
+        xml.add_element("EnableAddBillCard").text = 1
+      end
+      
+      def add_amount(xml, money, options)
+        xml.add_element("Amount").text = amount(money)
+        xml.add_element("InputCurrency").text = options[:currency] || currency(money)
+      end
+      
+      def add_transaction_type(xml, action)
+        xml.add_element("TxnType").text = TRANSACTIONS[action]
+      end
+      
+      def add_invoice(xml, options)
+        xml.add_element("TxnId").text = options[:order_id].to_s.slice(0, 16) unless options[:order_id].blank?
+        xml.add_element("MerchantReference").text = options[:description] unless options[:description].blank?
+      end
+      
+      def add_address_verification_data(xml, options)
+        address = options[:billing_address] || options[:address]
+        return if address.nil?
+        
+        xml.add_element("EnableAvsData").text = 1
+        xml.add_element("AvsAction").text = 1
+        
+        xml.add_element("AvsStreetAddress").text = address[:address1]
+        xml.add_element("AvsPostCode").text = address[:zip]
+      end
+      
+      def new_transaction
+        REXML::Document.new.add_element("Txn")
+      end
+
+      # Take in the request and post it to DPS
+      def commit(action, request)
+        add_credentials(request)
+        add_transaction_type(request, action)
+        
+        # Parse the XML response
+        response = parse( ssl_post(URL, request.to_s) )
+        
+        # Return a response
+        PaymentExpressResponse.new(response[:success] == APPROVED, response[:card_holder_help_text], response,
+          :test => response[:test_mode] == '1',
+          :authorization => response[:dps_txn_ref]
+        )
+      end
+
+      # Response XML documentation: http://www.paymentexpress.com/technical_resources/ecommerce_nonhosted/pxpost.html#XMLTxnOutput
+      def parse(xml_string)
+        response = {}
+
+        xml = REXML::Document.new(xml_string)          
+
+        # Gather all root elements such as HelpText
+        xml.elements.each('Txn/*') do |element|
+          response[element.name.underscore.to_sym] = element.text unless element.name == 'Transaction'
+        end
+
+        # Gather all transaction elements and prefix with "account_"
+        # So we could access the MerchantResponseText by going
+        # response[account_merchant_response_text]
+        xml.elements.each('Txn/Transaction/*') do |element|
+          response[element.name.underscore.to_sym] = element.text
+        end
+        
+        response
+      end
+      
+      def format_date(month, year)
+        "#{format(month, :two_digits)}#{format(year, :two_digits)}"
+      end
+    end
+    
+    class PaymentExpressResponse < Response
+      # add a method to response so we can easily get the token
+      # for Validate transactions
+      def token
+        @params["billing_id"] || @params["dps_billing_id"]
+      end
+    end
+  end
+end

data/lib/active_merchant/billing/gateways/paypal/paypal_common_api.rb

@@ -0,0 +1,351 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    # This module is included in both PaypalGateway and PaypalExpressGateway
+    module PaypalCommonAPI
+      def self.included(base)
+        base.default_currency = 'USD'
+        base.cattr_accessor :pem_file
+        base.cattr_accessor :signature
+      end
+      
+      API_VERSION = '62.0'
+      
+      URLS = {
+        :test => { :certificate => 'https://api.sandbox.paypal.com/2.0/',
+                   :signature   => 'https://api-3t.sandbox.paypal.com/2.0/' },
+        :live => { :certificate => 'https://api-aa.paypal.com/2.0/',
+                   :signature   => 'https://api-3t.paypal.com/2.0/' }
+      }
+      
+      PAYPAL_NAMESPACE = 'urn:ebay:api:PayPalAPI'
+      EBAY_NAMESPACE = 'urn:ebay:apis:eBLBaseComponents'
+      
+      ENVELOPE_NAMESPACES = { 'xmlns:xsd' => 'http://www.w3.org/2001/XMLSchema',
+                              'xmlns:env' => 'http://schemas.xmlsoap.org/soap/envelope/',
+                              'xmlns:xsi' => 'http://www.w3.org/2001/XMLSchema-instance'
+                            }
+      CREDENTIALS_NAMESPACES = { 'xmlns' => PAYPAL_NAMESPACE,
+                                 'xmlns:n1' => EBAY_NAMESPACE,
+                                 'env:mustUnderstand' => '0'
+                               }
+      
+      AUSTRALIAN_STATES = {
+        'ACT' => 'Australian Capital Territory',
+        'NSW' => 'New South Wales',
+        'NT'  => 'Northern Territory',
+        'QLD' => 'Queensland',
+        'SA'  => 'South Australia',
+        'TAS' => 'Tasmania',
+        'VIC' => 'Victoria',
+        'WA'  => 'Western Australia'
+      }
+      
+      SUCCESS_CODES = [ 'Success', 'SuccessWithWarning' ]
+      
+      FRAUD_REVIEW_CODE = "11610"
+      
+      # The gateway must be configured with either your PayPal PEM file
+      # or your PayPal API Signature.  Only one is required.
+      #
+      # <tt>:pem</tt>         The text of your PayPal PEM file. Note
+      #                       this is not the path to file, but its
+      #                       contents. If you are only using one PEM
+      #                       file on your site you can declare it
+      #                       globally and then you won't need to
+      #                       include this option
+      #
+      # <tt>:signature</tt>   The text of your PayPal signature. 
+      #                       If you are only using one API Signature
+      #                       on your site you can declare it
+      #                       globally and then you won't need to
+      #                       include this option
+      
+      def initialize(options = {})
+        requires!(options, :login, :password)
+        
+        @options = {
+          :pem => pem_file,
+          :signature => signature
+        }.update(options)
+        
+        if @options[:pem].blank? && @options[:signature].blank?
+          raise ArgumentError, "An API Certificate or API Signature is required to make requests to PayPal" 
+        end
+        
+        super
+      end
+      
+      def test?
+        @options[:test] || Base.gateway_mode == :test
+      end
+
+      def reauthorize(money, authorization, options = {})
+        commit 'DoReauthorization', build_reauthorize_request(money, authorization, options)
+      end
+      
+      def capture(money, authorization, options = {})
+        commit 'DoCapture', build_capture_request(money, authorization, options)
+      end
+      
+      # Transfer money to one or more recipients.
+      #
+      #   gateway.transfer 1000, 'bob@example.com',
+      #     :subject => "The money I owe you", :note => "Sorry it's so late"
+      #
+      #   gateway.transfer [1000, 'fred@example.com'],
+      #     [2450, 'wilma@example.com', :note => 'You will receive another payment on 3/24'],
+      #     [2000, 'barney@example.com'],
+      #     :subject => "Your Earnings", :note => "Thanks for your business."
+      #
+      def transfer(*args)
+        commit 'MassPay', build_mass_pay_request(*args)
+      end
+
+      def void(authorization, options = {})
+        commit 'DoVoid', build_void_request(authorization, options)
+      end
+      
+      def refund(money, identification, options = {})
+        commit 'RefundTransaction', build_refund_request(money, identification, options)
+      end
+
+      def credit(money, identification, options = {})
+        deprecated Gateway::CREDIT_DEPRECATION_MESSAGE
+        refund(money, identification, options)
+      end
+
+      private
+      def build_reauthorize_request(money, authorization, options)
+        xml = Builder::XmlMarkup.new
+        
+        xml.tag! 'DoReauthorizationReq', 'xmlns' => PAYPAL_NAMESPACE do
+          xml.tag! 'DoReauthorizationRequest', 'xmlns:n2' => EBAY_NAMESPACE do
+            xml.tag! 'n2:Version', API_VERSION
+            xml.tag! 'AuthorizationID', authorization
+            xml.tag! 'Amount', amount(money), 'currencyID' => options[:currency] || currency(money)
+          end
+        end
+
+        xml.target!        
+      end
+          
+      def build_capture_request(money, authorization, options)   
+        xml = Builder::XmlMarkup.new
+        
+        xml.tag! 'DoCaptureReq', 'xmlns' => PAYPAL_NAMESPACE do
+          xml.tag! 'DoCaptureRequest', 'xmlns:n2' => EBAY_NAMESPACE do
+            xml.tag! 'n2:Version', API_VERSION
+            xml.tag! 'AuthorizationID', authorization
+            xml.tag! 'Amount', amount(money), 'currencyID' => options[:currency] || currency(money)
+            xml.tag! 'CompleteType', 'Complete'
+            xml.tag! 'InvoiceID', options[:order_id] unless options[:order_id].blank?
+            xml.tag! 'Note', options[:description]
+          end
+        end
+
+        xml.target!        
+      end
+      
+      def build_refund_request(money, identification, options)
+        xml = Builder::XmlMarkup.new
+            
+        xml.tag! 'RefundTransactionReq', 'xmlns' => PAYPAL_NAMESPACE do
+          xml.tag! 'RefundTransactionRequest', 'xmlns:n2' => EBAY_NAMESPACE do
+            xml.tag! 'n2:Version', API_VERSION
+            xml.tag! 'TransactionID', identification
+            xml.tag! 'Amount', amount(money), 'currencyID' => options[:currency] || currency(money)
+            xml.tag! 'RefundType', 'Partial'
+            xml.tag! 'Memo', options[:note] unless options[:note].blank?
+          end
+        end
+      
+        xml.target!        
+      end
+      
+      def build_void_request(authorization, options)
+        xml = Builder::XmlMarkup.new
+        
+        xml.tag! 'DoVoidReq', 'xmlns' => PAYPAL_NAMESPACE do
+          xml.tag! 'DoVoidRequest', 'xmlns:n2' => EBAY_NAMESPACE do
+            xml.tag! 'n2:Version', API_VERSION
+            xml.tag! 'AuthorizationID', authorization
+            xml.tag! 'Note', options[:description]
+          end
+        end
+
+        xml.target!        
+      end
+      
+      def build_mass_pay_request(*args)   
+        default_options = args.last.is_a?(Hash) ? args.pop : {}
+        recipients = args.first.is_a?(Array) ? args : [args]
+        
+        xml = Builder::XmlMarkup.new
+        
+        xml.tag! 'MassPayReq', 'xmlns' => PAYPAL_NAMESPACE do
+          xml.tag! 'MassPayRequest', 'xmlns:n2' => EBAY_NAMESPACE do
+            xml.tag! 'n2:Version', API_VERSION
+            xml.tag! 'EmailSubject', default_options[:subject] if default_options[:subject]
+            recipients.each do |money, recipient, options|
+              options ||= default_options
+              xml.tag! 'MassPayItem' do
+                xml.tag! 'ReceiverEmail', recipient
+                xml.tag! 'Amount', amount(money), 'currencyID' => options[:currency] || currency(money)
+                xml.tag! 'Note', options[:note] if options[:note]
+                xml.tag! 'UniqueId', options[:unique_id] if options[:unique_id]
+              end
+            end
+          end
+        end
+        
+        xml.target!
+      end
+
+      def parse(action, xml)
+        legacy_hash = legacy_parse(action, xml)
+        xml = strip_attributes(xml)
+        hash = Hash.from_xml(xml)
+        hash = hash.fetch('Envelope').fetch('Body').fetch("#{action}Response")
+        hash = hash["#{action}ResponseDetails"] if hash["#{action}ResponseDetails"]
+
+        legacy_hash.merge(hash)
+      rescue IndexError
+        legacy_hash.merge(hash['Envelope']['Body'])
+      end
+
+      def strip_attributes(xml)
+        xml = REXML::Document.new(xml)
+        REXML::XPath.each(xml, '//SOAP-ENV:Envelope//*[@*]') do |el|
+          el.attributes.each_attribute { |a| a.remove }
+        end
+        xml.to_s
+      end
+
+      def legacy_parse(action, xml)
+        response = {}
+        
+        error_messages = []
+        error_codes = []
+        
+        xml = REXML::Document.new(xml)
+        if root = REXML::XPath.first(xml, "//#{action}Response")
+          root.elements.each do |node|            
+            case node.name
+            when 'Errors'
+              short_message = nil
+              long_message = nil
+              
+              node.elements.each do |child|
+                case child.name
+                when "LongMessage"
+                  long_message = child.text unless child.text.blank?
+                when "ShortMessage"
+                  short_message = child.text unless child.text.blank?
+                when "ErrorCode"
+                  error_codes << child.text unless child.text.blank?
+                end
+              end
+
+              if message = long_message || short_message
+                error_messages << message
+              end
+            else
+              legacy_parse_element(response, node)
+            end
+          end
+          response[:message] = error_messages.uniq.join(". ") unless error_messages.empty?
+          response[:error_codes] = error_codes.uniq.join(",") unless error_codes.empty?
+        elsif root = REXML::XPath.first(xml, "//SOAP-ENV:Fault")
+          legacy_parse_element(response, root)
+          response[:message] = "#{response[:faultcode]}: #{response[:faultstring]} - #{response[:detail]}"
+        end
+
+        response
+      end
+
+      def legacy_parse_element(response, node)
+        if node.has_elements?
+          node.elements.each{|e| legacy_parse_element(response, e) }
+        else
+          response[node.name.underscore.to_sym] = node.text
+          node.attributes.each do |k, v|
+            response["#{node.name.underscore}_#{k.underscore}".to_sym] = v if k == 'currencyID'
+          end
+        end
+      end
+
+      def build_request(body)
+        xml = Builder::XmlMarkup.new
+        
+        xml.instruct!
+        xml.tag! 'env:Envelope', ENVELOPE_NAMESPACES do
+          xml.tag! 'env:Header' do
+            add_credentials(xml)
+          end
+          
+          xml.tag! 'env:Body' do
+            xml << body
+          end
+        end
+        xml.target!
+      end
+     
+      def add_credentials(xml)
+        xml.tag! 'RequesterCredentials', CREDENTIALS_NAMESPACES do
+          xml.tag! 'n1:Credentials' do
+            xml.tag! 'Username', @options[:login]
+            xml.tag! 'Password', @options[:password]
+            xml.tag! 'Subject', @options[:subject]
+            xml.tag! 'Signature', @options[:signature] unless @options[:signature].blank?
+          end
+        end
+      end
+      
+      def add_address(xml, element, address)
+        return if address.nil?
+        xml.tag! element do
+          xml.tag! 'n2:Name', address[:name]
+          xml.tag! 'n2:Street1', address[:address1]
+          xml.tag! 'n2:Street2', address[:address2]
+          xml.tag! 'n2:CityName', address[:city]
+          xml.tag! 'n2:StateOrProvince', address[:state].blank? ? 'N/A' : address[:state]
+          xml.tag! 'n2:Country', address[:country]
+          xml.tag! 'n2:PostalCode', address[:zip]
+          xml.tag! 'n2:Phone', address[:phone]
+        end
+      end
+      
+      def endpoint_url
+        URLS[test? ? :test : :live][@options[:signature].blank? ? :certificate : :signature]
+      end
+
+      def commit(action, request)
+        response = parse(action, ssl_post(endpoint_url, build_request(request)))
+       
+        build_response(successful?(response), message_from(response), response,
+    	    :test => test?,
+    	    :authorization => authorization_from(response),
+    	    :fraud_review => fraud_review?(response),
+    	    :avs_result => { :code => response[:avs_code] },
+    	    :cvv_result => response[:cvv2_code]
+        )
+      end
+      
+      def fraud_review?(response)
+        response[:error_codes] == FRAUD_REVIEW_CODE
+      end
+      
+      def authorization_from(response)
+        response[:transaction_id] || response[:authorization_id] || response[:refund_transaction_id] # middle one is from reauthorization
+      end
+      
+      def successful?(response)
+        SUCCESS_CODES.include?(response[:ack])
+      end
+      
+      def message_from(response)
+        response[:message] || response[:ack]
+      end
+    end
+  end
+end

data/lib/active_merchant/billing/gateways/paypal/paypal_express_response.rb

@@ -0,0 +1,49 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class PaypalExpressResponse < Response
+      def email
+        info['Payer']
+      end
+
+      def info
+        (@params['PayerInfo']||{})
+      end
+      
+      def name
+        payer = (info['PayerName']||{})
+        [payer['FirstName'], payer['MiddleName'], payer['LastName']].compact.join(' ')
+      end
+      
+      def token
+        @params['Token']
+      end
+      
+      def payer_id
+        info['PayerID']
+      end
+      
+      def payer_country
+        info['PayerCountry']
+      end
+      
+      # PayPal returns a contact telephone number only if your Merchant account profile settings require that the buyer enter one.
+      def contact_phone
+        @params['ContactPhone']
+      end
+      
+      def address
+        address = (@params['PaymentDetails']||{})['ShipToAddress']
+        {  'name'       => address['Name'],
+           'company'    => info['PayerBusiness'],
+           'address1'   => address['Street1'],
+           'address2'   => address['Street2'],
+           'city'       => address['CityName'],
+           'state'      => address['StateOrProvince'],
+           'country'    => address['Country'],
+           'zip'        => address['PostalCode'],
+           'phone'      => (contact_phone || address['Phone'])
+        }
+      end
+    end
+  end
+end