activemerchant 1.43.3 → 1.44.0

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

@@ -1,145 +0,0 @@
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
-    module Integrations #:nodoc:
-      module WirecardCheckoutPage
-        class Helper < ActiveMerchant::Billing::Integrations::Helper
-          include Common
-
-          PLUGIN_NAME = 'ActiveMerchant_WirecardCheckoutPage'
-          PLUGIN_VERSION = '1.0.0'
-
-          # Replace with the real mapping
-          mapping :account, 'customerId'
-          mapping :amount, 'amount'
-
-          mapping :order, 'xActiveMerchantOrderId'
-
-          mapping :customer, :first_name => 'consumerBillingFirstName',
-                  :last_name => 'consumerBillingLastName',
-                  :email => 'consumerEmail',
-                  :phone => 'consumerBillingPhone',
-                  :ipaddress => 'consumerIpAddress',
-                  :user_agent => 'consumerUserAgent',
-                  :fax => 'consumerBillingFax',
-                  :birthdate => 'consumerBirthDate' # mandatory for INVOICE and INSTALLMENT
-
-          mapping :billing_address, :city => 'consumerBillingCity',
-                  :address1 => 'consumerBillingAddress1',
-                  :address2 => 'consumerBillingAddress2',
-                  :state => 'consumerBillingState',
-                  :zip => 'consumerBillingZipCode',
-                  :country => 'consumerBillingCountry'
-
-          mapping :shipping_address, :first_name => 'consumerShippingFirstName',
-                  :last_name => 'consumerShippingLastName',
-                  :address1 => 'consumerShippingAddress1',
-                  :address2 => 'consumerShippingAddress2',
-                  :city => 'consumerShippingCity',
-                  :state => 'consumerShippingState',
-                  :country => 'consumerShippingCountry',
-                  :zip => 'consumerShippingZipCode',
-                  :phone => 'consumerShippingPhone',
-                  :fax => 'consumerShippingFax'
-
-          mapping :currency, 'currency'
-          mapping :language, 'language' # language for displayed texts on payment page
-
-          mapping :description, 'orderDescription' # unique description of the consumer's order in a human readable form
-
-          mapping :shop_service_url, 'serviceUrl' # URL of your service page containing contact information
-
-          mapping :notify_url, 'confirmUrl'
-          mapping :return_url, 'successUrl'
-
-          # defaulting to return_url
-          mapping :cancel_return_url, 'cancelUrl'
-          mapping :pending_url, 'pendingUrl'
-          mapping :failure_url, 'failureUrl'
-
-          # optional parameters
-          mapping :window_name, 'windowName' # window.name of browser window where payment page is opened
-          mapping :duplicate_request_check, 'duplicateRequestCheck' # check for duplicate requests done by your consumer
-          mapping :customer_statement, 'customerStatement' # text displayed on invoice of financial institution of your consumer
-          mapping :order_reference, 'orderReference' # unique order reference id sent from merchant to financial institution
-          mapping :display_text, 'displayText' # text displayed to your consumer within the payment page
-          mapping :image_url, 'imageUrl' #  URL of your web shop where your web shop logo is located
-          mapping :max_retries, 'maxRetries' # maximum number of attempted payments for the same order
-          mapping :auto_deposit, 'autoDeposit' # enable automated debiting of payments
-          mapping :financial_institution, 'financialInstitution' # based on pre-selected payment type a sub-selection of financial institutions regarding to pre-selected payment type
-
-          # not used
-          mapping :tax, ''
-          mapping :shipping, ''
-
-          def initialize(order, customer_id, options = {})
-            @paymenttype = options.delete(:paymenttype)
-
-            raise "Unknown Paymenttype: " + @paymenttype if paymenttypes.find_index(@paymenttype) == nil
-
-            @secret = options.delete(:secret)
-            @customer_id = customer_id
-            @shop_id = options.delete(:shop_id)
-            super
-          end
-
-          def add_version(shop_name, shop_version)
-            add_field('pluginVersion', Base64.encode64(shop_name + ';' + shop_version + ';ActiveMerchant;' + PLUGIN_NAME + ';' + PLUGIN_VERSION))
-          end
-
-          def add_standard_fields
-            addfields = {}
-            addfields['shopId'] = @shop_id if !@shop_id.blank?
-            addfields['paymentType'] = @paymenttype
-
-            addfields[mappings[:pending_url]] = @fields[mappings[:return_url]] unless @fields.has_key?(mappings[:pending_url])
-            addfields[mappings[:cancel_return_url]] = @fields[mappings[:return_url]] unless @fields.has_key?(mappings[:cancel_return_url])
-            addfields[mappings[:failure_url]] = @fields[mappings[:return_url]] unless @fields.has_key?(mappings[:failure_url])
-
-            addfields
-          end
-
-          def add_request_fingerprint(fpfields)
-            addfields = {}
-            fingerprint_order = %w(secret)
-            fingerprint_values = @secret.to_s
-            fpfields.each { |key, value|
-              next if key == 'pluginVersion'
-              fingerprint_order.append key
-              fingerprint_values += value.to_s
-            }
-
-            fingerprint_order.append 'requestFingerprintOrder'
-            fingerprint_values += fingerprint_order.join(',')
-
-            addfields['requestFingerprintOrder'] = fingerprint_order.join(',')
-            addfields['requestFingerprint'] = Digest::MD5.hexdigest(fingerprint_values)
-
-            return addfields
-          end
-
-          def form_fields
-            result = {}
-            result.merge!(@fields)
-            result.merge!(add_standard_fields)
-            result.merge!(add_request_fingerprint(result))
-            result
-          end
-
-          def secret
-            @secret
-          end
-
-          def customer_id
-            @customer_id
-          end
-
-          def shop_id
-            @shop_id
-          end
-
-        end
-
-      end
-    end
-  end
-end

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

@@ -1,101 +0,0 @@
-require 'net/http'
-
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
-    module Integrations #:nodoc:
-      module WirecardCheckoutPage
-        class Notification < ActiveMerchant::Billing::Integrations::Notification
-          include Common
-
-          def complete?
-            @paymentstate == 'SUCCESS'
-          end
-
-          def item_id
-            params['xActiveMerchantOrderId']
-          end
-
-          def transaction_id
-            params['orderNumber']
-          end
-
-          # When was this payment received by the client.
-          def received_at
-            nil
-          end
-
-          # the money amount we received in X.2 decimal.
-          def gross
-            params['amount']
-          end
-
-          # Was this a test transaction?
-          def test?
-            false
-          end
-
-          def status
-            case @paymentstate
-              when 'SUCCESS'
-                'Completed'
-              when 'PENDING'
-                'Pending'
-              when 'CANCEL'
-                'Cancelled'
-              when 'FAILURE'
-                'Failed'
-              else
-                'Error'
-            end
-          end
-
-          def status_code
-            @paymentstate
-          end
-
-
-          # Acknowledge the transaction to WirecardCheckoutPage. This method has to be called after a new
-          # apc arrives. WirecardCheckoutPage will verify that all the information we received are correct and will return a
-          # ok or a fail.
-          #
-          # Example:
-          #
-          #   def ipn
-          #     notify = WirecardCheckoutPageNotification.new(request.raw_post, options)
-          #
-          #     if notify.acknowledge
-          #       ... process order ... if notify.complete?
-          #     else
-          #       ... log possible hacking attempt ...
-          #     end
-          def acknowledge
-            verify_response(params, @options[:secret])
-          end
-
-          def response(umessage = nil)
-            if @message || umessage
-              '<QPAY-CONFIRMATION-RESPONSE result="NOK" message="' + CGI.escapeHTML(umessage ? umessage : @message) + '"/>'
-            else
-              '<QPAY-CONFIRMATION-RESPONSE result="OK"/>'
-            end
-          end
-
-          def method_missing(method_id, *args)
-            return params[method_id.to_s] if params.has_key?(method_id.to_s)
-          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('&')
-              key, value = *line.scan( %r{^([A-Za-z0-9_.]+)\=(.*)$} ).flatten
-              params[key] = CGI.unescape(value)
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,35 +0,0 @@
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
-    module Integrations #:nodoc:
-      module WirecardCheckoutPage
-        class Return < ActiveMerchant::Billing::Integrations::Return
-          include Common
-
-          def initialize(postdata, options = {})
-            @params  = parse(postdata)
-            @options = options
-            verify_response(@params, options[:secret])
-          end
-
-          def success?
-            @paymentstate == 'SUCCESS'
-          end
-
-          def cancelled?
-            @paymentstate == 'CANCEL'
-          end
-
-          def pending?
-            @paymentstate == 'PENDING'
-          end
-
-          def method_missing(method_id, *args)
-            return params[method_id.to_s] if params.has_key?(method_id.to_s)
-          end
-
-        end
-      end
-    end
-  end
-end
-

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

@@ -1,34 +0,0 @@
-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
-
-        mattr_accessor :production_url, :test_url
-        self.production_url = 'https://secure.worldpay.com/wcc/purchase'
-        self.test_url = 'https://secure-test.worldpay.com/wcc/purchase'
-
-        def self.service_url
-          case ActiveMerchant::Billing::Base.integration_mode
-          when :production
-            self.production_url
-          when :test
-            self.test_url
-          else
-            raise StandardError, "Integration mode set to an invalid value: #{mode}"
-          end
-        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

@@ -1,101 +0,0 @@
-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'
-          mapping :return_url, 'MC_return'
-          
-          
-          # 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 further 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

@@ -1,160 +0,0 @@
-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(authcode = nil)
-            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