n8_activemerchant 1.9.3

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

@@ -0,0 +1,120 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class PaySecureGateway < Gateway
+      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)
+        @options = options
+        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(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,203 @@
+require 'iconv'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class PayboxDirectGateway < Gateway
+      TEST_URL = 'https://ppps.paybox.com/PPPS.php'
+      TEST_URL_BACKUP = 'https://ppps1.paybox.com/PPPS.php'
+      LIVE_URL = 'https://ppps.paybox.com/PPPS.php'
+      LIVE_URL_BACKUP = 'https://ppps1.paybox.com/PPPS.php'
+
+      # Payment API Version
+      API_VERSION = '00104'
+
+      # 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']
+      FRAUD_CODES = ['00102','00104','00105','00134','00138','00141','00143','00156','00157','00159']
+      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)
+        @options = options
+        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 = {})
+        post = {}
+        add_invoice(post, options)
+        add_reference(post, identification)
+        commit('refund', money, post)
+      end
+
+      def test?
+        @options[:test] || Base.gateway_mode == :test
+      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)
+        body = Iconv.iconv("UTF-8","LATIN1", body.to_s).join
+        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? ? TEST_URL : LIVE_URL, request_data))
+        response = parse(ssl_post(test? ? TEST_URL_BACKUP : LIVE_URL_BACKUP, request_data)) if service_unavailable?(response)
+        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 => fraud_review?(response),
+          :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 fraud_review?(response)
+        FRAUD_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.rb

@@ -0,0 +1,236 @@
+require File.dirname(__FILE__) + '/payflow/payflow_common_api'
+require File.dirname(__FILE__) + '/payflow/payflow_response'
+require File.dirname(__FILE__) + '/payflow_express'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class PayflowGateway < Gateway
+      include PayflowCommonAPI
+      
+      RECURRING_ACTIONS = Set.new([:add, :modify, :cancel, :inquiry, :reactivate, :payment])
+       
+      self.supported_cardtypes = [:visa, :master, :american_express, :jcb, :discover, :diners_club]
+      self.homepage_url = 'https://www.paypal.com/cgi-bin/webscr?cmd=_payflow-pro-overview-outside'
+      self.display_name = 'PayPal Payflow Pro'
+    
+      def authorize(money, credit_card_or_reference, options = {})
+        request = build_sale_or_authorization_request(:authorization, money, credit_card_or_reference, options)
+      
+        commit(request)
+      end
+      
+      def purchase(money, credit_card_or_reference, options = {})
+        request = build_sale_or_authorization_request(:purchase, money, credit_card_or_reference, options)
+
+        commit(request)
+      end
+      
+      def credit(money, identification_or_credit_card, options = {})
+        if identification_or_credit_card.is_a?(String)
+          # Perform referenced credit
+          request = build_reference_request(:credit, money, identification_or_credit_card, options)
+        else
+          # Perform non-referenced credit
+          request = build_credit_card_request(:credit, money, identification_or_credit_card, options)
+        end
+        
+        commit(request)
+      end
+      
+      # Adds or modifies a recurring Payflow profile.  See the Payflow Pro Recurring Billing Guide for more details:
+      # https://www.paypal.com/en_US/pdf/PayflowPro_RecurringBilling_Guide.pdf
+      #    
+      # Several options are available to customize the recurring profile:
+      #
+      # * <tt>profile_id</tt> - is only required for editing a recurring profile
+      # * <tt>starting_at</tt> - takes a Date, Time, or string in mmddyyyy format. The date must be in the future.
+      # * <tt>name</tt> - The name of the customer to be billed.  If not specified, the name from the credit card is used.
+      # * <tt>periodicity</tt> - The frequency that the recurring payments will occur at.  Can be one of
+      # :bimonthly, :monthly, :biweekly, :weekly, :yearly, :daily, :semimonthly, :quadweekly, :quarterly, :semiyearly
+      # * <tt>payments</tt> - The term, or number of payments that will be made
+      # * <tt>comment</tt> - A comment associated with the profile            
+      def recurring(money, credit_card, options = {})
+        options[:name] = credit_card.name if options[:name].blank? && credit_card
+        request = build_recurring_request(options[:profile_id] ? :modify : :add, money, options) do |xml|
+          add_credit_card(xml, credit_card) if credit_card
+        end
+        commit(request, :recurring)
+      end
+      
+      def cancel_recurring(profile_id)
+        request = build_recurring_request(:cancel, 0, :profile_id => profile_id)
+        commit(request, :recurring)
+      end
+      
+      def recurring_inquiry(profile_id, options = {})
+        request = build_recurring_request(:inquiry, nil, options.update( :profile_id => profile_id ))
+        commit(request, :recurring)
+      end   
+      
+      def express
+        @express ||= PayflowExpressGateway.new(@options)
+      end
+      
+      private
+      def build_sale_or_authorization_request(action, money, credit_card_or_reference, options)
+        if credit_card_or_reference.is_a?(String)
+          build_reference_sale_or_authorization_request(action, money, credit_card_or_reference, options)
+        else  
+          build_credit_card_request(action, money, credit_card_or_reference, options)
+        end  
+      end
+      
+      def build_reference_sale_or_authorization_request(action, money, reference, options)
+        xml = Builder::XmlMarkup.new 
+        xml.tag! TRANSACTIONS[action] do
+          xml.tag! 'PayData' do
+            xml.tag! 'Invoice' do
+              xml.tag! 'TotalAmt', amount(money), 'Currency' => options[:currency] || currency(money)
+            end
+            xml.tag! 'Tender' do
+              xml.tag! 'Card' do
+                xml.tag! 'ExtData', 'Name' => 'ORIGID', 'Value' =>  reference
+              end
+            end
+          end
+        end
+        xml.target!
+      end
+      
+      def build_credit_card_request(action, money, credit_card, options)
+        xml = Builder::XmlMarkup.new 
+        xml.tag! TRANSACTIONS[action] do
+          xml.tag! 'PayData' do
+            xml.tag! 'Invoice' do
+              xml.tag! 'CustIP', options[:ip] unless options[:ip].blank?
+              xml.tag! 'InvNum', options[:order_id].to_s.gsub(/[^\w.]/, '') unless options[:order_id].blank?
+              xml.tag! 'Description', options[:description] unless options[:description].blank?
+
+              billing_address = options[:billing_address] || options[:address]
+              add_address(xml, 'BillTo', billing_address, options) if billing_address
+              add_address(xml, 'ShipTo', options[:shipping_address], options) if options[:shipping_address]
+              
+              xml.tag! 'TotalAmt', amount(money), 'Currency' => options[:currency] || currency(money)
+            end
+            
+            xml.tag! 'Tender' do
+              add_credit_card(xml, credit_card)
+            end
+          end 
+        end
+        xml.target!
+      end
+    
+      def add_credit_card(xml, credit_card)
+        xml.tag! 'Card' do
+          xml.tag! 'CardType', credit_card_type(credit_card)
+          xml.tag! 'CardNum', credit_card.number
+          xml.tag! 'ExpDate', expdate(credit_card)
+          xml.tag! 'NameOnCard', credit_card.first_name
+          xml.tag! 'CVNum', credit_card.verification_value if credit_card.verification_value?
+          
+          if requires_start_date_or_issue_number?(credit_card)
+            xml.tag!('ExtData', 'Name' => 'CardStart', 'Value' => startdate(credit_card)) unless credit_card.start_month.blank? || credit_card.start_year.blank?
+            xml.tag!('ExtData', 'Name' => 'CardIssue', 'Value' => format(credit_card.issue_number, :two_digits)) unless credit_card.issue_number.blank?
+          end
+          xml.tag! 'ExtData', 'Name' => 'LASTNAME', 'Value' =>  credit_card.last_name
+        end
+      end
+      
+      def credit_card_type(credit_card)
+        return '' if card_brand(credit_card).blank?
+        
+        CARD_MAPPING[card_brand(credit_card).to_sym]
+      end
+      
+      def expdate(creditcard)
+        year  = sprintf("%.4i", creditcard.year)
+        month = sprintf("%.2i", creditcard.month)
+
+        "#{year}#{month}"
+      end
+      
+      def startdate(creditcard)
+        year  = format(creditcard.start_year, :two_digits)
+        month = format(creditcard.start_month, :two_digits)
+
+        "#{month}#{year}"
+      end
+      
+      def build_recurring_request(action, money, options)
+        unless RECURRING_ACTIONS.include?(action)
+          raise StandardError, "Invalid Recurring Profile Action: #{action}"
+        end
+
+        xml = Builder::XmlMarkup.new 
+        xml.tag! 'RecurringProfiles' do
+          xml.tag! 'RecurringProfile' do
+            xml.tag! action.to_s.capitalize do
+              unless [:cancel, :inquiry].include?(action)
+                xml.tag! 'RPData' do
+                  xml.tag! 'Name', options[:name] unless options[:name].nil?
+                  xml.tag! 'TotalAmt', amount(money), 'Currency' => options[:currency] || currency(money)
+                  xml.tag! 'PayPeriod', get_pay_period(options)
+                  xml.tag! 'Term', options[:payments] unless options[:payments].nil?
+                  xml.tag! 'Comment', options[:comment] unless options[:comment].nil?
+                
+                
+                  if initial_tx = options[:initial_transaction]
+                    requires!(initial_tx, [:type, :authorization, :purchase])
+                    requires!(initial_tx, :amount) if initial_tx[:type] == :purchase
+                      
+                    xml.tag! 'OptionalTrans', TRANSACTIONS[initial_tx[:type]]
+                    xml.tag! 'OptionalTransAmt', amount(initial_tx[:amount]) unless initial_tx[:amount].blank?
+                  end
+                
+                  xml.tag! 'Start', format_rp_date(options[:starting_at] || Date.today + 1 )
+                  xml.tag! 'EMail', options[:email] unless options[:email].nil?
+                  
+                  billing_address = options[:billing_address] || options[:address]
+                  add_address(xml, 'BillTo', billing_address, options) if billing_address
+                  add_address(xml, 'ShipTo', options[:shipping_address], options) if options[:shipping_address]
+                end
+                xml.tag! 'Tender' do
+                  yield xml
+                end
+              end
+              if action != :add
+                xml.tag! "ProfileID", options[:profile_id]
+              end
+              if action == :inquiry
+                xml.tag! "PaymentHistory", ( options[:history] ? 'Y' : 'N' )
+              end
+            end
+          end
+        end
+      end
+
+      def get_pay_period(options)
+        requires!(options, [:periodicity, :bimonthly, :monthly, :biweekly, :weekly, :yearly, :daily, :semimonthly, :quadweekly, :quarterly, :semiyearly])
+        case options[:periodicity]
+          when :weekly then 'Weekly'
+          when :biweekly then 'Bi-weekly'
+          when :semimonthly then 'Semi-monthly'
+          when :quadweekly then 'Every four weeks'
+          when :monthly then 'Monthly'
+          when :quarterly then 'Quarterly'
+          when :semiyearly then 'Semi-yearly'
+          when :yearly then 'Yearly'
+        end
+      end
+
+      def format_rp_date(time)
+        case time
+          when Time, Date then time.strftime("%m%d%Y")
+        else
+          time.to_s
+        end
+      end
+      
+      def build_response(success, message, response, options = {}) 
+        PayflowResponse.new(success, message, response, options)
+      end
+    end
+  end
+end
+