activemerchant 1.32.0 → 1.33.0

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

@@ -0,0 +1,239 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class TransnationalGateway < Gateway
+      self.live_url = self.test_url = 'https://secure.networkmerchants.com/api/transact.php'
+
+      self.supported_countries = ['US']
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover]
+
+      self.homepage_url = 'http://www.tnbci.com/'
+      self.display_name = 'Transnational'
+
+      self.money_format = :dollars
+      self.default_currency = 'USD'
+
+      def initialize(options = {})
+        requires!(options, :login, :password)
+        super
+      end
+
+      def authorize(money, creditcard_or_vault_id, options = {})
+        post = build_auth_post(money, creditcard_or_vault_id, options)
+        commit('auth', post)
+      end
+
+      def purchase(money, creditcard_or_vault_id, options = {})
+        post = build_purchase_post(money, creditcard_or_vault_id, options)
+        commit('sale', post)
+      end
+
+      def capture(money, authorization, options = {})
+        post = build_capture_post(money, authorization, options)
+        commit('capture', post)
+      end
+
+      def void(authorization, options = {})
+        post = build_void_post(authorization, options)
+        commit('void', post)
+      end
+
+      def refund(money, authorization, options = {})
+        post = build_refund_post(money, authorization, options)
+        commit('refund', post)
+      end
+
+      def store(creditcard, options = {})
+        post = build_store_post(creditcard, options)
+        commit_vault('add_customer', post)
+      end
+
+      def unstore(customer_vault_id, options = {})
+        post = build_unstore_post(customer_vault_id, options)
+        commit_vault('delete_customer', post)
+      end
+
+      private
+
+      def build_auth_post(money, creditcard_or_vault_id, options)
+        post = {}
+        add_order(post, options)
+        add_address(post, options)
+        add_shipping_address(post, options)
+        add_payment_method(post, creditcard_or_vault_id, options)
+        add_amount(post, money)
+        post
+      end
+
+      def build_purchase_post(money, creditcard, options)
+        build_auth_post(money, creditcard, options)
+      end
+
+      def build_capture_post(money, authorization, option)
+        post = {}
+        post[:transactionid] = authorization
+        add_amount(post, money)
+        post
+      end
+
+      def build_void_post(authorization, options)
+        post = {}
+        post[:transactionid] = authorization
+        post
+      end
+
+      def build_refund_post(money, authorization, options)
+        post = {}
+        post[:transactionid] = authorization
+        add_amount(post, money)
+        post
+      end
+
+      def build_store_post(creditcard_or_check, options)
+        post = {}
+        add_address(post, options)
+        add_shipping_address(post, options)
+        add_payment_method(post, creditcard_or_check, options)
+        post
+      end
+
+      def build_unstore_post(customer_vault_id, options)
+        post = {}
+        post['customer_vault_id'] = customer_vault_id
+        post
+      end
+
+      def add_order(post, options)
+        post[:orderid] = options[:order_id]
+        post[:orderdescription] = options[:description]
+      end
+
+      def add_address(post, options)
+        post[:email] = options[:email]
+        post[:ipaddress] = options[:ip]
+
+        address = options[:billing_address] || options[:address] || {}
+        post[:address1] = address[:address1]
+        post[:address2] = address[:address2]
+        post[:city] = address[:city]
+        post[:state] = address[:state]
+        post[:zip] = address[:zip]
+        post[:country] = address[:country]
+        post[:phone] = address[:phone]
+      end
+
+      def add_shipping_address(post, options)
+        shipping_address = options[:shipping_address] || {}
+        post[:shipping_address1] = shipping_address[:address1]
+        post[:shipping_address2] = shipping_address[:address2]
+        post[:shipping_city] = shipping_address[:city]
+        post[:shipping_state] = shipping_address[:state]
+        post[:shipping_zip] = shipping_address[:zip]
+        post[:shipping_country] = shipping_address[:country]
+      end
+
+      def add_swipe_data(post, options)
+        # unencrypted tracks
+        post[:track_1] = options[:track_1]
+        post[:track_2] = options[:track_2]
+        post[:track_3] = options[:track_3]
+
+        # encrypted tracks
+        post[:magnesafe_track_1] = options[:magnesafe_track_1]
+        post[:magnesafe_track_2] = options[:magnesafe_track_2]
+        post[:magnesafe_track_3] = options[:magnesafe_track_3]
+        post[:magnesafe_magneprint] = options[:magnesafe_magneprint]
+        post[:magnesafe_ksn] = options[:magnesafe_ksn]
+        post[:magnesafe_magneprint_status] = options[:magnesafe_magneprint_status]
+      end
+
+      def add_payment_method(post, creditcard_or_check_or_vault_id, options)
+        post[:processor_id] = options[:processor_id]
+        post[:customer_vault] = 'add_customer' if options[:store]
+
+        add_swipe_data(post, options)
+
+        # creditcard_or_check can be blank if using swipe data
+        if creditcard_or_check_or_vault_id.is_a?(CreditCard) # creditcard or check
+          creditcard = creditcard_or_check_or_vault_id
+          post[:firstname] = creditcard.first_name
+          post[:lastname] = creditcard.last_name
+          post[:ccnumber] = creditcard.number
+          post[:ccexp] = format(creditcard.month, :two_digits) + format(creditcard.year, :two_digits)
+          post[:cvv] = creditcard.verification_value
+          post[:payment] = 'creditcard'
+        elsif creditcard_or_check_or_vault_id.is_a?(Check)
+          check = creditcard_or_check_or_vault_id
+          post[:firstname] = check.first_name
+          post[:lastname] = check.last_name
+          post[:checkname] = check.name
+          post[:checkaba] = check.routing_number
+          post[:checkaccount] = check.account_number
+          post[:account_type] = check.account_type
+          post[:account_holder_type] = check.account_holder_type
+          post[:payment] = 'check'
+        else
+          post[:customer_vault_id] = creditcard_or_check_or_vault_id
+        end
+      end
+
+      def add_login(post)
+        post[:username] = @options[:login]
+        post[:password] = @options[:password]
+      end
+
+      def add_amount(post, money)
+        post[:currency] = options[:currency] || currency(money)
+        post[:amount] = amount(money)
+      end
+
+      def commit_vault(action, parameters)
+        commit(nil, parameters.merge(:customer_vault => action))
+      end
+
+      def commit(action, parameters)
+        raw = parse(ssl_post(self.live_url, build_request(action, parameters)))
+
+        success = (raw['response'] == ResponseCodes::APPROVED)
+
+        authorization = authorization_from(success, parameters, raw)
+
+        Response.new(success, raw['responsetext'], raw,
+          :test => test?,
+          :authorization => authorization,
+          :avs_result => { :code => raw['avsresponse']},
+          :cvv_result => raw['cvvresponse']
+        )
+      end
+
+      def build_request(action, parameters)
+        parameters[:type] = action if action
+        add_login(parameters)
+        parameters.to_query
+      end
+
+      def authorization_from(success, parameters, response)
+        return nil unless success
+
+        authorization = response['transactionid']
+        if(parameters[:customer_vault] && (authorization.nil? || authorization.empty?))
+          authorization = response['customer_vault_id']
+        end
+
+        authorization
+      end
+
+      class ResponseCodes
+        APPROVED = '1'
+        DENIED = '2'
+        ERROR = '3'
+      end
+
+      def parse(raw_response)
+        rsp = CGI.parse(raw_response)
+        rsp.keys.each { |k| rsp[k] = rsp[k].first } # flatten out the values
+        rsp
+      end
+    end
+  end
+end
+

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

@@ -174,7 +174,7 @@ module ActiveMerchant #:nodoc:
         :xid => [:string, 'XID'],
         :cavv => [:string, 'CAVV'],
         :eci => [:integer, 'ECI'],
-        :internal_card_authorization => [:boolean, 'InternalCardAduth'],
+        :internal_card_authorization => [:boolean, 'InternalCardAuth'],
         :pares => [:string, 'Pares']
       } #:nodoc:
 
@@ -283,14 +283,19 @@ module ActiveMerchant #:nodoc:
         void_transaction(options.merge!(:reference_number => identification))
       end
 
-      # Credit a previous transaction.
+      # Refund a previous transaction.
       #
       # Note: See run_transaction for additional options.
       #
-      def credit(money, identification, options={})
+      def refund(money, identification, options={})
         refund_transaction(options.merge!(:amount => money, :reference_number => identification))
       end
 
+      def credit(money, identification, options={})
+        deprecated CREDIT_DEPRECATION_MESSAGE
+        refund(money, identification, options)
+      end
+
       # Customer ======================================================
 
       # Add a customer.
@@ -1334,7 +1339,7 @@ module ActiveMerchant #:nodoc:
 
       def build_check_data(soap, options)
         soap.CheckData 'xsi:type' => "ns1:CheckData" do |soap|
-          build_tag soap, :string, 'Account', options[:payment_method].number
+          build_tag soap, :string, 'Account', options[:payment_method].account_number
           build_tag soap, :string, 'Routing', options[:payment_method].routing_number
           build_tag soap, :string, 'AccountType', options[:payment_method].account_type.capitalize
           CHECK_DATA_OPTIONS.each do |k,v|

data/lib/active_merchant/billing/integrations/direc_pay/status.rb

@@ -6,7 +6,7 @@ module ActiveMerchant #:nodoc:
         class Status
           include PostsData
                     
-          STATUS_TEST_URL = 'https://test.timesofmoney.com/direcpay/secure/dpPullMerchAtrnDtls.jsp'
+          STATUS_TEST_URL = 'https://test.direcpay.com/direcpay/secure/dpMerchantTransaction.jsp'
           STATUS_LIVE_URL = 'https://www.timesofmoney.com/direcpay/secure/dpPullMerchAtrnDtls.jsp'
           
           attr_reader :account, :options

data/lib/active_merchant/billing/integrations/direc_pay.rb

@@ -10,7 +10,7 @@ module ActiveMerchant #:nodoc:
         mattr_accessor :production_url, :test_url
         
         self.production_url = "https://www.timesofmoney.com/direcpay/secure/dpMerchantTransaction.jsp"
-        self.test_url       = "https://test.timesofmoney.com/direcpay/secure/dpMerchantTransaction.jsp"
+        self.test_url       = "https://test.direcpay.com/direcpay/secure/dpMerchantTransaction.jsp"
 
         def self.service_url
           mode = ActiveMerchant::Billing::Base.integration_mode

data/lib/active_merchant/billing/integrations/dwolla/common.rb

@@ -0,0 +1,21 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    module Integrations #:nodoc:
+      module Dwolla
+        module Common
+          def verify_signature(checkoutId, amount, notification_signature, secret)
+            if secret.nil?
+              raise ArgumentError, "You need to provide the Application secret as the option :credential3 to verify that the notification originated from Dwolla"
+            end
+
+            expected_signature = Digest::SHA1.hexdigest(secret + ('%s&%.2f' % [checkoutId, amount]))
+
+            if notification_signature != expected_signature
+              raise StandardError, "Dwolla signature verification failed."
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_merchant/billing/integrations/dwolla/helper.rb

@@ -1,29 +1,38 @@
+require 'digest/sha1'
+
 module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
     module Integrations #:nodoc:
       module Dwolla
         class Helper < ActiveMerchant::Billing::Integrations::Helper
-
           def initialize(order, account, options = {})
             super
             add_field('name', 'Store Purchase')
 
             if ActiveMerchant::Billing::Base.integration_mode == :test || options[:test]
               add_field('test', 'true')
-            end 
+            end
+
+            timestamp = Time.now.to_i.to_s
+            add_field('timestamp', timestamp)
+            add_field('allowFundingSources', 'true')
+
+            key = options[:credential2].to_s
+            secret = options[:credential3].to_s
+            orderid = order.to_s
+            signature = Digest::SHA1.hexdigest(secret + "#{key}&#{timestamp}&#{orderid}")
+            add_field('signature', signature)
           end
-          
-          # Replace with the real mapping
+
           mapping :account, 'destinationid'
           mapping :credential2, 'key'
-          mapping :credential3, 'secret'
           mapping :notify_url, 'callback'
           mapping :return_url, 'redirect'
           mapping :description, 'description'
           mapping :amount, 'amount'
           mapping :tax, 'tax'
           mapping :shipping, 'shipping'
-          mapping :order, 'orderid'          
+          mapping :order, 'orderid'
         end
       end
     end

data/lib/active_merchant/billing/integrations/dwolla/notification.rb

@@ -1,12 +1,15 @@
 require 'net/http'
+require 'digest/sha1'
 
 module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
     module Integrations #:nodoc:
       module Dwolla
         class Notification < ActiveMerchant::Billing::Integrations::Notification
+          include Common
+
           def complete?
-            status == "Completed"
+            (status == "Completed")
           end
 
           def status
@@ -30,22 +33,24 @@ module ActiveMerchant #:nodoc:
           end
 
           def error
-            params['Message']
+            params['Error']
           end
 
-          # Was this a test transaction?
           def test?
             params['TestMode']
           end
 
-          def acknowledge      
+          def acknowledge
             true
           end
- private
-          # Take the posted data and move the relevant data into a hash
+
+          private
+
           def parse(post)
             @raw = post.to_s
             json_post = JSON.parse(post)
+            verify_signature(json_post['CheckoutId'], json_post['Amount'], json_post['Signature'], @options[:credential3])
+
             params.merge!(json_post)
           end
         end

data/lib/active_merchant/billing/integrations/dwolla/return.rb

@@ -3,9 +3,17 @@ module ActiveMerchant #:nodoc:
     module Integrations #:nodoc:
       module Dwolla
         class Return < ActiveMerchant::Billing::Integrations::Return
+          include Common
+
+          def initialize(data, options)
+            params = parse(data)
+            verify_signature(params['checkoutId'], params['amount'], params['signature'], options[:credential3])
+
+            super
+          end
 
           def success?
-            self.error.nil? && self.callback_success?
+            (self.error.nil? && self.callback_success?)
           end
 
           def error
@@ -17,7 +25,7 @@ module ActiveMerchant #:nodoc:
           end
 
           def checkout_id
-            params['checkoutid']
+            params['checkoutId']
           end
 
           def transaction
@@ -29,9 +37,9 @@ module ActiveMerchant #:nodoc:
           end
 
           def callback_success?
-            params['postback'] != "failure"
+            (params['postback'] != "failure")
           end
-	      end
+        end
       end
     end
   end

data/lib/active_merchant/billing/integrations/dwolla.rb

@@ -1,28 +1,21 @@
-# All mappings in helper.rb are required fields to be sent to Dwolla.
-# :account = 'Dwolla Id of merchant'
-# :credential1 = 'key from Dwolla Application'
-# :credential2 = 'secret from Dwolla Application'
-# :redirect_url = 'can be different that what is specified on Dwolla Application creation'
-# :return_url = 'can be different that what is specified on Dwolla Application creation'
-# :order_id = must be unique for each transaction
-
 module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
     module Integrations #:nodoc:
-      module Dwolla 
+      module Dwolla
         autoload :Return, 'active_merchant/billing/integrations/dwolla/return.rb'
         autoload :Helper, 'active_merchant/billing/integrations/dwolla/helper.rb'
         autoload :Notification, 'active_merchant/billing/integrations/dwolla/notification.rb'
-       
+        autoload :Common, 'active_merchant/billing/integrations/dwolla/common.rb'
+
         mattr_accessor :service_url
         self.service_url = 'https://www.dwolla.com/payment/pay'
 
         def self.notification(post, options={})
-          Notification.new(post)
+          Notification.new(post, options)
         end
 
         def self.return(query_string, options={})
-          Return.new(query_string)
+          Return.new(query_string, options)
         end
       end
     end

data/lib/active_merchant/billing/integrations/notification.rb

@@ -4,10 +4,15 @@ module ActiveMerchant #:nodoc:
       class Notification
         attr_accessor :params
         attr_accessor :raw
-        
-        # set this to an array in the subclass, to specify which IPs are allowed to send requests
+
+        # set this to an array in the subclass, to specify which IPs are allowed
+        # to send requests
         class_attribute :production_ips
 
+        # * *Args*    :
+        #   - +doc+ ->     raw post string
+        #   - +options+ -> custom options which individual implementations can
+        #                  utilize
         def initialize(post, options = {})
           @options = options
           empty!
@@ -27,19 +32,19 @@ module ActiveMerchant #:nodoc:
           (gross.to_f * 100.0).round
         end
 
-        # This combines the gross and currency and returns a proper Money object. 
+        # This combines the gross and currency and returns a proper Money object.
         # this requires the money library located at http://dist.leetsoft.com/api/money
         def amount
           return Money.new(gross_cents, currency) rescue ArgumentError
           return Money.new(gross_cents) # maybe you have an own money object which doesn't take a currency?
         end
 
-        # reset the notification. 
+        # reset the notification.
         def empty!
           @params  = Hash.new
-          @raw     = ""      
+          @raw     = ""
         end
-        
+
         # Check if the request comes from an official IP
         def valid_sender?(ip)
           return true if ActiveMerchant::Billing::Base.integration_mode == :test || production_ips.blank?
@@ -49,13 +54,13 @@ module ActiveMerchant #:nodoc:
         def test?
           false
         end
-        
+
         private
 
         # Take the posted data and move the relevant data into a hash
         def parse(post)
           @raw = post.to_s
-          for line in @raw.split('&')    
+          for line in @raw.split('&')
             key, value = *line.scan( %r{^([A-Za-z0-9_.]+)\=(.*)$} ).flatten
             params[key] = CGI.unescape(value)
           end

data/lib/active_merchant/billing/integrations/payflow_link/helper.rb

@@ -35,7 +35,7 @@ module ActiveMerchant #:nodoc:
           mapping :customer, { :first_name => 'first_name', :last_name => 'last_name' }
 
           def description(value)
-            add_field('description', "#{value}".delete("#"))
+            add_field('description', normalize("#{value}").delete("#"))
           end
 
           def customer(params = {})
@@ -97,6 +97,18 @@ module ActiveMerchant #:nodoc:
 
             [response['SECURETOKEN'], response['SECURETOKENID']] if response['RESPMSG'] && response['RESPMSG'].downcase == "approved"
           end
+
+          def normalize(text)
+            return unless text
+
+            if ActiveSupport::Inflector.method(:transliterate).arity == -2
+              ActiveSupport::Inflector.transliterate(text,'')
+            elsif RUBY_VERSION >= '1.9'
+              text.gsub(/[^\x00-\x7F]+/, '')
+            else
+              ActiveSupport::Inflector.transliterate(text).to_s
+            end
+          end
         end
       end
     end

data/lib/active_merchant/billing/integrations/payu_in/helper.rb

@@ -0,0 +1,74 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    module Integrations #:nodoc:
+      module PayuIn
+        class Helper < ActiveMerchant::Billing::Integrations::Helper
+
+          mapping :amount, 'amount'
+          mapping :account, 'key'
+          mapping :order, 'txnid'
+          mapping :credential2, 'productinfo'
+
+          mapping :customer, :first_name => 'firstname',
+            :last_name  => 'lastname',
+            :email => 'email',
+            :phone => 'phone'
+
+          mapping :billing_address, :city => 'city',
+            :address1 => 'address1',
+            :address2 => 'address2',
+            :state => 'state',
+            :zip => 'zip',
+            :country => 'country'
+
+          # Which tab you want to be open default on PayU
+          # CC (CreditCard) or NB (NetBanking)
+          mapping :mode, 'pg'
+
+          mapping :notify_url, 'notify_url'
+          mapping :return_url, ['surl', 'furl']
+          mapping :cancel_return_url, 'curl'
+          mapping :checksum, 'hash'
+
+          mapping :user_defined, { :var1 => 'udf1',
+            :var2 => 'udf2',
+            :var3 => 'udf3',
+            :var4 => 'udf4',
+            :var5 => 'udf5',
+            :var6 => 'udf6',
+            :var7 => 'udf7',
+            :var8 => 'udf8',
+            :var9 => 'udf9',
+            :var10 => 'udf10'
+          }
+
+          def initialize(order, account, options = {})
+            super
+            self.pg = 'CC'
+          end
+
+          def form_fields
+            @fields.merge(mappings[:checksum] => generate_checksum)
+          end
+
+          def generate_checksum(  options = {} )
+            checksum_fields = [ :order, :amount, :credential2, { :customer => [ :first_name, :email ] },
+              { :user_defined => [ :var1, :var2, :var3, :var4, :var5, :var6, :var7, :var8, :var9, :var10 ] } ]
+            checksum_payload_items = checksum_fields.inject( [] ) do | items, field |
+              if Hash === field then
+                key = field.keys.first
+                field[key].inject( items ){ |s,x| items.push( @fields[ mappings[key][x] ] ) }
+              else
+                items.push( @fields[ mappings[field] ] )
+              end
+            end
+            checksum_payload_items.push( options )
+            PayuIn.checksum(@fields["key"], @fields["productinfo"], *checksum_payload_items )
+          end
+
+        end
+
+      end
+    end
+  end
+end