bitfluent-activemerchant 1.5.1.1 → 1.15.1

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

@@ -0,0 +1,31 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    module Integrations #:nodoc:
+      module SagePayForm
+        class Return < ActiveMerchant::Billing::Integrations::Return
+
+          def initialize(query_string, options)
+            begin
+              @notification = Notification.new(query_string, options)
+            rescue Notification::CryptError => e
+              @message = e.message
+            end
+          end
+
+          def success?
+            @notification && @notification.complete?
+          end
+
+          def cancelled?
+            @notification && @notification.cancelled?
+          end
+
+          def message
+            @message || @notification.message
+          end
+
+        end
+      end
+    end
+  end
+end

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

@@ -10,11 +10,11 @@ module ActiveMerchant #:nodoc:
         mattr_accessor :service_url
         self.service_url = 'https://www.2checkout.com/2co/buyer/purchase'
 
-        def self.notification(post)
+        def self.notification(post, options = {})
           Notification.new(post)
         end  
         
-        def self.return(query_string)
+        def self.return(query_string, options = {})
           Return.new(query_string)
         end
       end

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

@@ -87,14 +87,14 @@ module ActiveMerchant #:nodoc:
             end
           end
           
-          def verify(secret)
-            return false if security_key.blank?
-            
-            Digest::MD5.hexdigest("#{secret}#{params['sid']}#{transaction_id}#{gross}").upcase == security_key.upcase
+          def secret
+            @options[:credential2]
           end
           
           def acknowledge
-            true
+            return false if security_key.blank?
+            
+            Digest::MD5.hexdigest("#{secret}#{params['sid']}#{transaction_id}#{gross}").upcase == security_key.upcase
           end
           
           private

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

@@ -0,0 +1,33 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    module Integrations #:nodoc:
+      module Valitor 
+        autoload :Return, 'active_merchant/billing/integrations/valitor/return.rb'
+        autoload :Helper, 'active_merchant/billing/integrations/valitor/helper.rb'
+        autoload :Notification, 'active_merchant/billing/integrations/valitor/notification.rb'
+
+        mattr_accessor :test_url
+        self.test_url = 'https://testvefverslun.valitor.is/1_1/'
+
+        mattr_accessor :production_url 
+        self.production_url = 'https://vefverslun.valitor.is/1_1/'
+        
+        def self.test?
+          (ActiveMerchant::Billing::Base.integration_mode == :test)
+        end
+
+        def self.service_url
+          (test? ? test_url : production_url)
+        end
+
+        def self.notification(params, options={})
+          Notification.new(params, options.merge(:test => test?))
+        end
+
+        def self.return(query_string, options={})
+          Return.new(query_string, options.merge(:test => test?))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+require 'digest/md5'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    module Integrations #:nodoc:
+      module Valitor
+        class Helper < ActiveMerchant::Billing::Integrations::Helper
+          include RequiresParameters
+          
+          DEFAULT_SUCCESS_TEXT = "The transaction has been completed."
+          
+          def initialize(order, account, options={})
+            options[:currency] ||= 'ISK'
+            super
+            add_field 'Adeinsheimild', '0'
+            add_field 'KaupandaUpplysingar', '0'
+            add_field 'SlokkvaHaus', '0'
+            @security_number = options[:credential2]
+            @amount          = options[:amount]
+            @order           = order
+          end
+          
+          mapping :account, 'VefverslunID'
+          mapping :currency, 'Gjaldmidill'
+
+          mapping :order, 'Tilvisunarnumer'
+
+          mapping :notify_url, 'SlodTokstAdGjaldfaeraServerSide'
+          mapping :return_url, 'SlodTokstAdGjaldfaera'
+          mapping :cancel_return_url, 'SlodNotandiHaettirVid'
+          
+          mapping :success_text, 'SlodTokstAdGjaldfaeraTexti'
+          
+          mapping :language, 'Lang'
+          
+          def authorize_only
+            add_field 'Adeinsheimild', '1'
+          end
+          
+          def collect_customer_info
+            add_field 'KaupandaUpplysingar', '1'
+          end
+          
+          def hide_header
+            add_field 'SlokkvaHaus', '1'
+          end
+          
+          def product(id, options={})
+            raise ArgumentError, "Product id #{id} is not an integer between 1 and 500" unless id.to_i > 0 && id.to_i <= 500
+            requires!(options, :amount, :description)
+            options.assert_valid_keys([:description, :quantity, :amount, :discount])
+
+            add_field("Vara_#{id}_Verd", format_amount(options[:amount]))
+            add_field("Vara_#{id}_Fjoldi", options[:quantity] || "1")
+            
+            add_field("Vara_#{id}_Lysing", options[:description]) if options[:description]
+            add_field("Vara_#{id}_Afslattur", options[:discount] || '0')
+            
+            @products ||= []
+            @products << id.to_i
+          end
+          
+          def signature
+            raise ArgumentError, "Security number not set" unless @security_number
+            parts = [@security_number, @fields['Adeinsheimild']]
+            @products.sort.uniq.each do |id|
+              parts.concat(["Vara_#{id}_Fjoldi", "Vara_#{id}_Verd", "Vara_#{id}_Afslattur"].collect{|e| @fields[e]})
+            end if @products
+            parts.concat(%w(VefverslunID Tilvisunarnumer SlodTokstAdGjaldfaera SlodTokstAdGjaldfaeraServerSide Gjaldmidill).collect{|e| @fields[e]})
+            Digest::MD5.hexdigest(parts.compact.join(''))
+          end
+
+          def form_fields
+            product(1, :amount => @amount, :description => @order) if Array(@products).empty?
+            @fields[mappings[:success_text]] ||= DEFAULT_SUCCESS_TEXT
+            @fields.merge('RafraenUndirskrift' => signature)
+          end
+          
+          def format_amount(amount)
+            amount.to_f.round
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+require 'active_merchant/billing/integrations/valitor/response_fields'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    module Integrations #:nodoc:
+      module Valitor
+        class Notification < ActiveMerchant::Billing::Integrations::Notification
+          include ResponseFields
+        end
+      end
+    end
+  end
+end

data/lib/active_merchant/billing/integrations/valitor/response_fields.rb

@@ -0,0 +1,88 @@
+require 'digest/md5'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    module Integrations #:nodoc:
+      module Valitor
+        module ResponseFields
+          def success?
+            acknowledge
+          end
+          alias :complete? :success?
+          
+          def test?
+            @options[:test]
+          end
+          
+          def order
+            params['Tilvisunarnumer']
+          end
+          
+          def received_at
+            params['Dagsetning']
+          end
+          
+          def transaction_id
+            params['VefverslunSalaID']
+          end
+          
+          def status
+            "OK"
+          end
+          
+          def card_type
+            params['Kortategund']
+          end
+          
+          def card_last_four
+            params['KortnumerSidustu']
+          end
+          
+          def authorization_number
+            params['Heimildarnumer']
+          end
+          
+          def transaction_number
+            params['Faerslunumer']
+          end
+          
+          def customer_name
+            params['Nafn']
+          end
+          
+          def customer_address
+            params['Heimilisfang']
+          end
+          
+          def customer_zip
+            params['Postnumer']
+          end
+          
+          def customer_city
+            params['Stadur']
+          end
+          
+          def customer_country
+            params['Land']
+          end
+          
+          def customer_email
+            params['Tolvupostfang']
+          end
+          
+          def customer_comment
+            params['Athugasemdir']
+          end
+          
+          def password
+            @options[:credential2]
+          end
+          
+          def acknowledge
+            password ? Digest::MD5.hexdigest("#{password}#{order}") == params['RafraenUndirskriftSvar'] : true
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+require 'active_merchant/billing/integrations/valitor/response_fields'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    module Integrations #:nodoc:
+      module Valitor
+        class Return < ActiveMerchant::Billing::Integrations::Return
+          include ResponseFields
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+require File.dirname(__FILE__) + '/world_pay/helper.rb'
+require File.dirname(__FILE__) + '/world_pay/notification.rb'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    module Integrations #:nodoc:
+      module WorldPay 
+       
+        # production and test have the same endpoint
+        mattr_accessor :production_url
+        self.production_url = 'https://secure.wp3.rbsworldpay.com/wcc/purchase'
+        
+        def self.service_url
+          production_url
+        end
+
+        def self.notification(post, options = {})
+          Notification.new(post, options)
+        end
+        
+        def self.return(post, options = {})
+          Return.new(post, options)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,100 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    module Integrations #:nodoc:
+      module WorldPay
+        class Helper < ActiveMerchant::Billing::Integrations::Helper
+          mapping :account, 'instId'
+          mapping :amount, 'amount'
+          mapping :order, 'cartId'
+          mapping :currency, 'currency'
+
+          mapping :customer, :email => 'email',
+                             :phone => 'tel'
+
+          mapping :billing_address, :zip => 'postcode',
+                                    :country  => 'country'
+
+          mapping :description, 'desc'
+          mapping :notify_url, 'MC_callback'
+          
+          
+          # WorldPay supports two different test modes - :always_succeed and :always_fail
+          def initialize(order, account, options = {})
+            super
+            
+            if ActiveMerchant::Billing::Base.integration_mode == :test || options[:test]
+              test_mode = case options[:test]
+              when :always_fail
+                101
+              when false
+                0
+              else
+                100
+              end
+              add_field('testMode', test_mode.to_s)
+            elsif ActiveMerchant::Billing::Base.integration_mode == :always_succeed
+              add_field('testMode', '100')
+            elsif ActiveMerchant::Billing::Base.integration_mode == :always_fail
+              add_field('testMode', '101')
+            end
+          end
+          
+          # WorldPay only supports a single address field so we 
+          # have to concat together - lines are separated using &#10;
+          def billing_address(params={})
+            add_field(mappings[:billing_address][:zip], params[:zip])
+            add_field(mappings[:billing_address][:country], lookup_country_code(params[:country]))
+            
+            address = [params[:address1], params[:address2], params[:city], params[:state]].compact
+            add_field('address', address.join('&#10;'))
+          end
+          
+          # WorldPay only supports a single name field so we have to concat
+          def customer(params={})
+            add_field(mappings[:customer][:email], params[:email])
+            add_field(mappings[:customer][:phone], params[:phone])
+            add_field('name', "#{params[:first_name]} #{params[:last_name]}")
+          end
+          
+          # Support for a MD5 hash of selected fields to prevent tampering
+          # For futher information read the tech note at the address below: 
+          # http://support.worldpay.com/kb/integration_guides/junior/integration/help/tech_notes/sjig_tn_009.html
+          def encrypt(secret, fields = [:amount, :currency, :account, :order])
+            signature_fields = fields.collect{ |field| mappings[field] }
+            add_field('signatureFields', signature_fields.join(':'))
+
+            field_values = fields.collect{ |field| form_fields[mappings[field]] }
+            signature    = "#{secret}:#{field_values.join(':')}"            
+            add_field('signature', Digest::MD5.hexdigest(signature))
+          end
+          
+          # Add a time window for which the payment can be completed. Read the link below for how they work
+          # http://support.worldpay.com/kb/integration_guides/junior/integration/help/appendicies/sjig_10100.html
+          def valid_from(from_time)
+            add_field('authValidFrom', from_time.to_i.to_s + '000')
+          end
+          
+          def valid_to(to_time)
+            add_field('authValidTo', to_time.to_i.to_s + '000')
+          end
+          
+          # WorldPay supports the passing of custom parameters prefixed with the following:
+          # C_          : These parameters can be used in the response pages hosted on WorldPay's site
+          # M_          : These parameters are passed through to the callback script (if enabled)
+          # MC_ or CM_  : These parameters are availble both in the response and callback contexts
+          def response_params(params={})
+            params.each{|k,v| add_field("C_#{k}",v)}
+          end
+          
+          def callback_params(params={})
+            params.each{|k,v| add_field("M_#{k}",v)}
+          end
+          
+          def combined_params(params={})
+            params.each{|k,v| add_field("MC_#{k}",v)}
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,160 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    module Integrations #:nodoc:
+      module WorldPay
+        class Notification < ActiveMerchant::Billing::Integrations::Notification
+          def complete?
+            status == 'Completed'
+          end 
+
+          def account
+            params['instId']
+          end
+
+          def item_id
+            params['cartId']
+          end
+
+          def transaction_id
+            params['transId']
+          end
+
+          # Time this payment was received by the client in UTC time.
+          def received_at
+            Time.at(params['transTime'].to_i / 1000).utc
+          end
+
+          # Callback password set in the WorldPay CMS
+          def security_key
+            params['callbackPW']
+          end
+
+          # the money amount we received in X.2 decimal.
+          def gross
+            params['authAmount']
+          end
+          
+          def currency
+            params['authCurrency']
+          end
+
+          # Was this a test transaction?
+          def test?
+            params.key?('testMode') && params['testMode'] != '0'
+          end
+
+          def status
+            params['transStatus'] == 'Y' ? 'Completed' : 'Cancelled'
+          end
+          
+          def name
+            params['name']
+          end
+          
+          def address
+            params['address']
+          end
+          
+          def postcode
+            params['postcode']
+          end
+          
+          def country
+            params['country']
+          end
+          
+          def phone_number
+            params['tel']
+          end
+          
+          def fax_number
+            params['fax']
+          end
+          
+          def email_address
+            params['email']
+          end
+          
+          def card_type
+            params['cardType']
+          end
+          
+          # WorldPay extended fraud checks returned as a 4 character string
+          #   1st char: Credit card CVV check
+          #   2nd char: Postcode AVS check
+          #   3rd char: Address AVS check
+          #   4th char: Country comparison check
+          # Possible values are:
+          #   :not_supported   -  0
+          #   :not_checked     -  1
+          #   :matched         -  2
+          #   :not_matched     -  4
+          #   :partial_match   -  8
+          def cvv_status
+            return avs_value_to_symbol(params['AVS'][0].chr)
+          end
+
+          def postcode_status
+            return avs_value_to_symbol(params['AVS'][1].chr)
+          end
+
+          def address_status
+            return avs_value_to_symbol(params['AVS'][2].chr)
+          end
+
+          def country_status
+            return avs_value_to_symbol(params['AVS'][3].chr)
+          end
+
+          def acknowledge
+            return true
+          end
+          
+          # WorldPay supports the passing of custom parameters through to the callback script
+          def custom_params
+            return @custom_params ||= read_custom_params
+          end
+          
+          
+          private
+
+          # Take the posted data and move the relevant data into a hash
+          def parse(post)
+            @raw = post
+            for line in post.split('&')
+              key, value = *line.scan( %r{^(\w+)\=(.*)$} ).flatten
+              params[key] = value
+            end
+          end
+          
+          # Read the custom params into a hash
+          def read_custom_params
+            custom = {}
+            params.each do |key, value|
+              if /\A(M_|MC_|CM_)/ === key
+                custom[key.gsub(/\A(M_|MC_|CM_)/, '').to_sym] = value
+              end
+            end
+            custom
+          end
+          
+          # Convert a AVS value to a symbol - see above for more about AVS
+          def avs_value_to_symbol(value)
+            case value.to_s
+            when '8'
+              :partial_match
+            when '4'
+              :no_match
+            when '2'
+              :matched
+            when '1'
+              :not_checked
+            else
+              :not_supported
+            end
+          end
+        end
+      end
+    end
+  end
+end