tanga_activemerchant 1.37.0

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

@@ -0,0 +1,119 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class PaySecureGateway < Gateway
+      self.live_url = self.test_url = 'https://clearance.commsecure.com.au/cgi-bin/PSDirect'
+
+      self.money_format = :cents
+
+      # Currently Authorization and Capture is not implemented because
+      # capturing requires the original credit card information
+      TRANSACTIONS = {
+        :purchase       => 'PURCHASE',
+        :authorization  => 'AUTHORISE',
+        :capture        => 'ADVICE',
+        :credit         => 'REFUND'
+      }
+
+      SUCCESS = 'Accepted'
+      SUCCESS_MESSAGE = 'The transaction was approved'
+
+      self.supported_countries = ['AU']
+      self.homepage_url = 'http://www.commsecure.com.au/paysecure.shtml'
+      self.display_name = 'PaySecure'
+      self.supported_cardtypes = [:visa, :master, :american_express, :diners_club]
+
+      def initialize(options = {})
+        requires!(options, :login, :password)
+        super
+      end
+
+      def purchase(money, credit_card, options = {})
+        requires!(options, :order_id)
+
+        post = {}
+        add_amount(post, money)
+        add_invoice(post, options)
+        add_credit_card(post, credit_card)
+
+        commit(:purchase, money, post)
+      end
+
+      private
+      # Used for capturing, which is currently not supported.
+      def add_reference(post, identification)
+        auth, trans_id = identification.split(";")
+        post[:authnum]    = auth
+        post[:transid] = trans_id
+      end
+
+      def add_amount(post, money)
+        post[:amount] = amount(money)
+      end
+
+      def add_invoice(post, options)
+        post[:merchant_transid] = options[:order_id].to_s.slice(0,21)
+        post[:memnum]           = options[:invoice]
+        post[:custnum]          = options[:customer]
+        post[:clientdata]       = options[:description]
+      end
+
+      def add_credit_card(post, credit_card)
+        post[:cardnum]  = credit_card.number
+        post[:cardname] = credit_card.name
+        post[:expiry]   = expdate(credit_card)
+        post[:cvv2]     = credit_card.verification_value
+      end
+
+      def expdate(credit_card)
+        year  = sprintf("%.4i", credit_card.year)
+        month = sprintf("%.2i", credit_card.month)
+
+        "#{month}#{year[-2..-1]}"
+      end
+
+      def commit(action, money, parameters)
+        response = parse( ssl_post(self.live_url, post_data(action, parameters)) )
+
+        Response.new(successful?(response), message_from(response), response,
+          :test => test_response?(response),
+          :authorization => authorization_from(response)
+        )
+
+      end
+
+      def successful?(response)
+        response[:status] == SUCCESS
+      end
+
+      def authorization_from(response)
+        [ response[:authnum], response[:transid] ].compact.join(";")
+      end
+
+      def test_response?(response)
+        !!(response[:transid] =~ /SimProxy/)
+      end
+
+      def message_from(response)
+        successful?(response) ? SUCCESS_MESSAGE : response[:errorstring]
+      end
+
+      def parse(body)
+        response = {}
+        body.to_s.each_line do |l|
+          key, value = l.split(":", 2)
+          response[key.to_s.downcase.to_sym] = value.strip
+        end
+        response
+      end
+
+      def post_data(action, parameters = {})
+        parameters[:request_type]     = TRANSACTIONS[action]
+        parameters[:merchant_id]      = @options[:login]
+        parameters[:password]         = @options[:password]
+
+        parameters.reject{|k,v| v.blank?}.collect { |key, value| "#{key.to_s.upcase}=#{CGI.escape(value.to_s)}" }.join("&")
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,196 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class PayboxDirectGateway < Gateway
+      class_attribute :live_url_backup
+
+      self.test_url   = 'https://preprod-ppps.paybox.com/PPPS.php'
+      self.live_url   = 'https://ppps.paybox.com/PPPS.php'
+      self.live_url_backup = 'https://ppps1.paybox.com/PPPS.php'
+
+      # Payment API Version
+      API_VERSION = '00103'
+
+      # Transactions hash
+      TRANSACTIONS = {
+        :authorization => '00001',
+        :capture => '00002',
+        :purchase => '00003',
+        :unreferenced_credit => '00004',
+        :void => '00005',
+        :refund => '00014'
+      }
+
+      CURRENCY_CODES = {
+        "AUD"=> '036',
+        "CAD"=> '124',
+        "CZK"=> '203',
+        "DKK"=> '208',
+        "HKD"=> '344',
+        "ICK"=> '352',
+        "JPY"=> '392',
+        "NOK"=> '578',
+        "SGD"=> '702',
+        "SEK"=> '752',
+        "CHF"=> '756',
+        "GBP"=> '826',
+        "USD"=> '840',
+        "EUR"=> '978'
+      }
+
+      SUCCESS_CODES = ['00000']
+      UNAVAILABILITY_CODES = ['00001', '00097', '00098']
+      SUCCESS_MESSAGE = 'The transaction was approved'
+      FAILURE_MESSAGE = 'The transaction failed'
+
+      # Money is referenced in cents
+      self.money_format = :cents
+      self.default_currency = 'EUR'
+
+      # The countries the gateway supports merchants from as 2 digit ISO country codes
+      self.supported_countries = ['FR']
+
+      # The card types supported by the payment gateway
+      self.supported_cardtypes = [:visa, :master, :american_express, :diners_club, :jcb]
+
+      # The homepage URL of the gateway
+      self.homepage_url = 'http://www.paybox.com/'
+
+      # The name of the gateway
+      self.display_name = 'Paybox Direct'
+
+      def initialize(options = {})
+        requires!(options, :login, :password)
+        super
+      end
+
+      def authorize(money, creditcard, options = {})
+        post = {}
+        add_invoice(post, options)
+        add_creditcard(post, creditcard)
+        commit('authorization', money, post)
+      end
+
+      def purchase(money, creditcard, options = {})
+        post = {}
+        add_invoice(post, options)
+        add_creditcard(post, creditcard)
+        commit('purchase', money, post)
+      end
+
+      def capture(money, authorization, options = {})
+        requires!(options, :order_id)
+        post = {}
+        add_invoice(post, options)
+        post[:numappel] = authorization[0,10]
+        post[:numtrans] = authorization[10,10]
+        commit('capture', money, post)
+      end
+
+      def void(identification, options = {})
+        requires!(options, :order_id, :amount)
+        post ={}
+        add_invoice(post, options)
+        add_reference(post, identification)
+        post[:porteur] = '000000000000000'
+        post[:dateval] = '0000'
+        commit('void', options[:amount], post)
+      end
+
+      def credit(money, identification, options = {})
+        deprecated CREDIT_DEPRECATION_MESSAGE
+        refund(money, identification, options)
+      end
+
+      def refund(money, identification, options = {})
+        post = {}
+        add_invoice(post, options)
+        add_reference(post, identification)
+        commit('refund', money, post)
+      end
+
+      private
+
+      def add_invoice(post, options)
+        post[:reference] = options[:order_id]
+      end
+
+      def add_creditcard(post, creditcard)
+        post[:porteur] = creditcard.number
+        post[:dateval] = expdate(creditcard)
+        post[:cvv] = creditcard.verification_value if creditcard.verification_value?
+      end
+
+      def add_reference(post, identification)
+        post[:numappel] = identification[0,10]
+        post[:numtrans] = identification[10,10]
+      end
+
+      def parse(body)
+        results = {}
+        body.split(/&/).each do |pair|
+          key,val = pair.split(/\=/)
+          results[key.downcase.to_sym] = CGI.unescape(val) if val
+        end
+        results
+      end
+
+      def commit(action, money = nil, parameters = nil)
+        parameters[:montant] = ('0000000000' + (money ? amount(money) : ''))[-10..-1]
+        parameters[:devise] = CURRENCY_CODES[options[:currency] || currency(money)]
+        request_data = post_data(action,parameters)
+        response = parse(ssl_post(test? ? self.test_url : self.live_url, request_data))
+        response = parse(ssl_post(self.live_url_backup, request_data)) if service_unavailable?(response) && !test?
+        Response.new(success?(response), message_from(response), response.merge(
+          :timestamp => parameters[:dateq]),
+          :test => test?,
+          :authorization => response[:numappel].to_s + response[:numtrans].to_s,
+          :fraud_review => false,
+          :sent_params => parameters.delete_if{|key,value| ['porteur','dateval','cvv'].include?(key.to_s)}
+        )
+      end
+
+      def success?(response)
+        SUCCESS_CODES.include?(response[:codereponse])
+      end
+
+      def service_unavailable?(response)
+        UNAVAILABILITY_CODES.include?(response[:codereponse])
+      end
+
+      def message_from(response)
+        success?(response) ? SUCCESS_MESSAGE : (response[:commentaire]  || FAILURE_MESSAGE)
+      end
+
+      def post_data(action, parameters = {})
+
+        parameters.update(
+          :version => API_VERSION,
+          :type => TRANSACTIONS[action.to_sym],
+          :dateq => Time.now.strftime('%d%m%Y%H%M%S'),
+          :numquestion => unique_id(parameters[:order_id]),
+          :site => @options[:login].to_s[0,7],
+          :rang => @options[:login].to_s[7..-1],
+          :cle => @options[:password],
+          :pays => '',
+          :archivage => parameters[:order_id]
+        )
+
+        parameters.collect { |key, value| "#{key.to_s.upcase}=#{CGI.escape(value.to_s)}" }.join("&")
+      end
+
+      def unique_id(seed = 0)
+        randkey = "#{seed}#{Time.now.usec}".to_i % 2147483647 # Max paybox value for the question number
+
+        "0000000000#{randkey}"[-10..-1]
+      end
+
+      def expdate(credit_card)
+        year  = sprintf("%.4i", credit_card.year)
+        month = sprintf("%.2i", credit_card.month)
+
+        "#{month}#{year[-2..-1]}"
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,209 @@
+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 = ['US', 'CA', 'SG', '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
+      end
+
+      XMLNS = 'http://www.paypal.com/XMLPay'
+
+      CARD_MAPPING = {
+        :visa => 'Visa',
+        :master => 'MasterCard',
+        :discover => 'Discover',
+        :american_express => 'Amex',
+        :jcb => 'JCB',
+        :diners_club => 'DinersClub',
+        :switch => 'Switch',
+        :solo => 'Solo'
+      }
+
+      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', '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?
+            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! '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
+
+        if tx_result && tx_result.attributes['Duplicate'].to_s == "true"
+          response[:duplicate] = true
+        end
+
+        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 node_name.to_s =~ /amt$/
+          # *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)
+        {
+          "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" => Utils.generate_unique_id
+    	  }
+    	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(response[:result] == "0", 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] }
+        )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+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 address
+        {  'name'       => 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'      => nil
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class PayflowResponse < Response
+      def profile_id
+        @params['profile_id']
+      end
+      
+      def payment_history
+        @payment_history ||= @params['rp_payment_result'].collect{ |result| result.stringify_keys } rescue []
+      end
+    end
+  end
+end