activemerchant 1.43.3 → 1.44.0

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

@@ -1,38 +0,0 @@
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
-    module Integrations #:nodoc:
-      module FirstData
-        autoload :Helper, 'active_merchant/billing/integrations/first_data/helper.rb'
-        autoload :Notification, 'active_merchant/billing/integrations/first_data/notification.rb'
-
-        # Overwrite this if you want to change the ANS test url
-        mattr_accessor :test_url
-        self.test_url = 'https://demo.globalgatewaye4.firstdata.com/payment'
-
-        # Overwrite this if you want to change the ANS production url
-        mattr_accessor :production_url
-        self.production_url = 'https://checkout.globalgatewaye4.firstdata.com/payment'
-
-        def self.service_url
-          mode = ActiveMerchant::Billing::Base.integration_mode
-          case 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)
-          Notification.new(post)
-        end
-
-        def self.return(query_string)
-          Return.new(query_string)
-        end
-      end
-    end
-  end
-end

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

@@ -1,61 +0,0 @@
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
-    module Integrations #:nodoc:
-      module FirstData
-        # First Data payment pages emulates the Authorize.Net SIM API. See
-        # ActiveMerchant::Billing::Integrations::AuthorizeNetSim::Helper for
-        # more details.
-        #
-        # An example. Note the username as a parameter and transaction key you
-        # will want to use later.
-        #
-        #  payment_service_for('order_id', 'first_data_payment_page_id', :service => :first_data,  :amount => 157.0) do |service|
-        #
-        #    # You must call setup_hash and invoice
-        #
-        #    service.setup_hash :transaction_key => '8CP6zJ7uD875J6tY',
-        #        :order_timestamp => 1206836763
-        #    service.customer_id 8
-        #    service.customer :first_name => 'g',
-        #                       :last_name => 'g',
-        #                       :email => 'g@g.com',
-        #                       :phone => '3'
-        #   service.billing_address :zip => 'g',
-        #                   :country => 'United States of America',
-        #                   :address => 'g'
-        #
-        #   service.ship_to_address :first_name => 'g',
-        #                            :last_name => 'g',
-        #                            :city => '',
-        #                            :address => 'g',
-        #                            :address2 => '',
-        #                            :state => address.state,
-        #                            :country => 'United States of America',
-        #                            :zip => 'g'
-        #
-        #   service.invoice "516428355" # your invoice number
-        #   # The end-user is presented with the HTML produced by the notify_url
-        #   # (using the First Data Receipt Link feature).
-        #   service.return_url "http://mysite/first_data_receipt_generator_page"
-        #   service.payment_header 'My store name'
-        #   service.add_line_item :name => 'item name', :quantity => 1, :unit_price => 0
-        #   service.test_request 'true' # only if it's just a test
-        #   service.shipping '25.0'
-        #   # Tell it to display a "0" line item for shipping, with the price in
-        #   # the name, otherwise it isn't shown at all, leaving the end user to
-        #   # wonder why the total is different than the sum of the line items.
-        #   service.add_shipping_as_line_item
-        #   server.add_tax_as_line_item # same with tax
-        #   # See the helper.rb file for various custom fields
-        # end
-        class Helper < ActiveMerchant::Billing::Integrations::AuthorizeNetSim::Helper
-          # Configure notify_url to use the "Relay Response" feature
-          mapping :notify_url, 'x_relay_url'
-
-          # Configure return_url to use the "Receipt Link" feature
-          mapping :return_url, 'x_receipt_link_url'
-        end
-      end
-    end
-  end
-end

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

@@ -1,56 +0,0 @@
-require 'net/http'
-
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
-    module Integrations #:nodoc:
-      # First Data payment pages emulates the Authorize.Net SIM API. See
-      # ActiveMerchant::Billing::Integrations::FirstData::Notification for
-      # more details.
-      #
-      # # Example:
-      # parser = FirstData::Notification.new(request.raw_post)
-      # passed = parser.complete?
-      #
-      # order = Order.find_by_order_number(parser.invoice_num)
-      #
-      # unless order
-      #   @message = 'Error--unable to find your transaction! Please contact us directly.'
-      #   return render :partial => 'first_data_payment_response'
-      # end
-      #
-      # if order.total != parser.gross.to_f
-      #   logger.error "First Data said they paid for #{parser.gross} and it should have been #{order.total}!"
-      #   passed = false
-      # end
-      #
-      # # Theoretically, First Data will *never* pass us the same transaction
-      # # ID twice, but we can double check that... by using
-      # # parser.transaction_id, and checking against previous orders' transaction
-      # # id's (which you can save when the order is completed)....
-      # unless parser.acknowledge FIRST_DATA_TRANSACTION_KEY, FIRST_DATA_RESPONSE_KEY
-      #  passed = false
-      #  logger.error "ALERT POSSIBLE FRAUD ATTEMPT"
-      # end
-      #
-      # unless parser.cavv_matches? and parser.avs_code_matches?
-      #   logger.error 'Warning--non matching CC!' + params.inspect
-      #   # Could fail them here, as well (recommended)...
-      # end
-      #
-      # if passed
-      #  # Set up your session, and render something that will redirect them to
-      #  # your site, most likely.
-      # else
-      #  # Render failure or redirect them to your site where you will render failure
-      # end
-
-      module FirstData
-        class Notification < ActiveMerchant::Billing::Integrations::AuthorizeNetSim::Notification
-          def acknowledge(response_key, payment_page_id)
-            Digest::MD5.hexdigest(response_key + payment_page_id + params['x_trans_id'] + sprintf('%.2f', gross)) == params['x_MD5_Hash'].downcase
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,25 +0,0 @@
-# With help from Giovanni Intini and his code for RGestPay - http://medlar.it/it/progetti/rgestpay
-
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
-    module Integrations #:nodoc:
-      module Gestpay 
-        autoload :Return, File.dirname(__FILE__) + '/gestpay/return.rb'
-        autoload :Common, File.dirname(__FILE__) + '/gestpay/common.rb'
-        autoload :Helper, File.dirname(__FILE__) + '/gestpay/helper.rb'
-        autoload :Notification, File.dirname(__FILE__) + '/gestpay/notification.rb'
-       
-        mattr_accessor :service_url
-        self.service_url = 'https://ecomm.sella.it/gestpay/pagam.asp'
-
-        def self.notification(post, options = {})
-          Notification.new(post)
-        end  
-        
-        def self.return(query_string, options = {})
-          Return.new(query_string)
-        end
-      end
-    end
-  end
-end

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

@@ -1,42 +0,0 @@
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
-    module Integrations #:nodoc:
-      module Gestpay
-        module Common
-          VERSION = "2.0"
-          ENCRYPTION_PATH = "/CryptHTTPS/Encrypt.asp"
-          DECRYPTION_PATH = "/CryptHTTPS/Decrypt.asp"
-          DELIMITER = '*P1*'
-          
-          CURRENCY_MAPPING = {
-            'EUR' => '242',
-            'ITL' => '18',
-            'BRL' => '234',
-            'USD' => '1',
-            'JPY' => '71',
-            'HKD' => '103'
-          }
-          
-          def parse_response(response)
-            case response
-            when /#cryptstring#(.*)#\/cryptstring#/, /#decryptstring#(.*)#\/decryptstring#/
-              $1
-            when /#error#(.*)#\/error#/
-              raise StandardError, "An error occurred retrieving the encrypted string from GestPay: #{$1}"
-            else
-              raise StandardError, "No response was received by GestPay"
-            end
-          end
-          
-          def ssl_get(url, path)
-            uri = URI.parse(url)
-            site = Net::HTTP.new(uri.host, uri.port)
-            site.use_ssl = true
-            site.verify_mode    = OpenSSL::SSL::VERIFY_NONE
-            site.get(path).body
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,70 +0,0 @@
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
-    module Integrations #:nodoc:
-      module Gestpay
-        class Helper < ActiveMerchant::Billing::Integrations::Helper
-          include Common
-          # Valid language codes
-          #   Italian		=> 1
-  				#	  English		=> 2
-  				#	  Spanish		=> 3
-  				#	  French    => 4
-  				#   Tedesco   => 5
-          def initialize(order, account, options = {})
-            super
-            add_field('PAY1_IDLANGUAGE', 2)
-          end
-       
-          mapping :account, 'ShopLogin'
-          
-          mapping :amount, 'PAY1_AMOUNT'
-          mapping :currency, 'PAY1_UICCODE'
-        
-          mapping :order, 'PAY1_SHOPTRANSACTIONID'
-
-          # Buyer name PAY1_CHNAME
-          mapping :customer, :email => 'PAY1_CHEMAIL'
-                                    
-          mapping :credit_card, :number       => 'PAY1_CARDNUMBER',
-                                :expiry_month => 'PAY1_EXPMONTH',
-                                :expiry_year  => 'PAY1_EXPYEAR',
-                                :verification_value => 'PAY1_CVV'
-          
-          def customer(params = {})
-            add_field(mappings[:customer][:email], params[:email])
-            add_field('PAY1_CHNAME', "#{params[:first_name]} #{params[:last_name]}")
-          end
-          
-          def currency=(currency_code)
-            code = CURRENCY_MAPPING[currency_code]
-  					raise StandardError, "Invalid currency code #{currency_code} specified" if code.nil?
-  					
-  					add_field(mappings[:currency], code)
-          end
-          
-          def form_fields
-            @encrypted_data ||= get_encrypted_string
-                      
-            {
-              'a' => @fields['ShopLogin'],
-              'b' => @encrypted_data
-            }
-          end
-          
-          def get_encrypted_string
-            response = ssl_get(Gestpay.service_url, encryption_query_string)
-            parse_response(response)
-          end
-          
-          def encryption_query_string
-            fields = ['PAY1_AMOUNT', 'PAY1_SHOPTRANSACTIONID', 'PAY1_UICCODE']
-          
-            encoded_params = fields.collect{ |field| "#{field}=#{CGI.escape(@fields[field])}" }.join(DELIMITER)
-          
-            "#{ENCRYPTION_PATH}?a=" + CGI.escape(@fields['ShopLogin']) + "&b=" + encoded_params + "&c=" + CGI.escape(VERSION)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,85 +0,0 @@
-require 'net/http'
-
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
-    module Integrations #:nodoc:
-      module Gestpay
-        class Notification < ActiveMerchant::Billing::Integrations::Notification
-          include Common
-          
-          def complete?
-            status == 'Completed'
-          end 
-
-          # The important param
-          def item_id
-            params['PAY1_SHOPTRANSACTIONID']
-          end
-
-          def transaction_id
-            params['PAY1_BANKTRANSACTIONID']
-          end
-
-          # the money amount we received in X.2 decimal.
-          def gross
-            params['PAY1_AMOUNT']
-          end
-          
-          def currency
-            # Ruby 1.9 compat
-            method = CURRENCY_MAPPING.respond_to?(:key) ? :key : :index
-            CURRENCY_MAPPING.send(method, params['PAY1_UICCODE'])
-          end
-
-          def test?
-            false
-          end
-
-          def status
-            case params['PAY1_TRANSACTIONRESULT']
-            when 'OK'
-              'Completed'
-            else
-              'Failed'
-            end
-          end
-
-          def acknowledge(authcode = nil)
-            true
-          end
-          
-          private
-          # Take the posted data and move the relevant data into a hash
-          def parse(query_string)
-            @raw = query_string
-            
-            return if query_string.blank?
-            encrypted_params = parse_delimited_string(query_string)
-            
-            return if encrypted_params['a'].blank? || encrypted_params['b'].blank?
-            @params = decrypt_data(encrypted_params['a'], encrypted_params['b'])
-          end
-          
-          def parse_delimited_string(string, delimiter = '&', unencode_cgi = false)
-            result = {}
-            for line in string.split(delimiter)
-              key, value = *line.scan( %r{^(\w+)\=(.*)$} ).flatten
-              result[key] = unencode_cgi ? CGI.unescape(value) : value
-            end
-            result
-          end
-          
-          def decrypt_data(shop_login, encrypted_string)
-            response = ssl_get(Gestpay.service_url, decryption_query_string(shop_login, encrypted_string))
-            encoded_response = parse_response(response)
-            parse_delimited_string(encoded_response, DELIMITER, true)
-          end
-        
-          def decryption_query_string(shop_login, encrypted_string)
-            "#{DECRYPTION_PATH}?a=" + CGI.escape(shop_login) + "&b=" + encrypted_string + "&c=" + CGI.escape(VERSION)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,10 +0,0 @@
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
-    module Integrations #:nodoc:
-      module Gestpay
-        class Return < ActiveMerchant::Billing::Integrations::Return
-	      end
-      end
-    end
-  end
-end

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

@@ -1,123 +0,0 @@
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
-    module Integrations #:nodoc:
-      class Helper #:nodoc:
-        attr_reader :fields
-        class_attribute :service_url
-        class_attribute :mappings
-        class_attribute :country_format
-        self.country_format = :alpha2
-
-        # The application making the calls to the gateway
-        # Useful for things like the PayPal build notation (BN) id fields
-        class_attribute :application_id
-        self.application_id = 'ActiveMerchant'
-
-        def self.inherited(subclass)
-          subclass.mappings ||= {}
-        end
-
-        def initialize(order, account, options = {})
-          options.assert_valid_keys([:amount, :currency, :test, :credential2, :credential3, :credential4, :country, :account_name, :description, :transaction_type, :authcode, :notify_url, :return_url, :redirect_param, :forward_url])
-          @fields             = {}
-          @raw_html_fields    = []
-          @test               = options[:test]
-          self.order          = order
-          self.account        = account
-          self.amount         = options[:amount]
-          self.currency       = options[:currency]
-          self.credential2    = options[:credential2]
-          self.credential3    = options[:credential3]
-          self.credential4    = options[:credential4]
-          self.notify_url     = options[:notify_url]
-          self.return_url     = options[:return_url]
-          self.redirect_param = options[:redirect_param]
-        end
-
-        def self.mapping(attribute, options = {})
-          self.mappings[attribute] = options
-        end
-
-        def add_field(name, value)
-          return if name.blank? || value.blank?
-          @fields[name.to_s] = value.to_s
-        end
-
-        def add_fields(subkey, params = {})
-          params.each do |k, v|
-            field = mappings[subkey][k]
-            add_field(field, v) unless field.blank?
-          end
-        end
-
-        # Add a field that has characters that CGI::escape would mangle. Allows
-        # for multiple fields with the same name (e.g., to support line items).
-        def add_raw_html_field(name, value)
-          return if name.blank? || value.blank?
-          @raw_html_fields << [name, value]
-        end
-
-        def raw_html_fields
-          @raw_html_fields
-        end
-
-        def billing_address(params = {})
-          add_address(:billing_address, params)
-        end
-
-        def shipping_address(params = {})
-          add_address(:shipping_address, params)
-        end
-
-        def form_fields
-          @fields
-        end
-
-        def test?
-          @test_mode ||= ActiveMerchant::Billing::Base.integration_mode == :test || @test
-        end
-
-        def form_method
-          "POST"
-        end
-
-        private
-
-        def add_address(key, params)
-          return if mappings[key].nil?
-
-          code = lookup_country_code(params.delete(:country))
-          add_field(mappings[key][:country], code)
-          add_fields(key, params)
-        end
-
-        def lookup_country_code(name_or_code, format = country_format)
-          country = Country.find(name_or_code)
-          country.code(format).to_s
-        rescue InvalidCountryCodeError
-          name_or_code
-        end
-
-        def method_missing(method_id, *args)
-          method_id = method_id.to_s.gsub(/=$/, '').to_sym
-          # Return and do nothing if the mapping was not found. This allows
-          # for easy substitution of the different integrations
-          return if mappings[method_id].nil?
-
-          mapping = mappings[method_id]
-
-          case mapping
-          when Array
-            mapping.each{ |field| add_field(field, args.last) }
-          when Hash
-            options = args.last.is_a?(Hash) ? args.pop : {}
-
-            mapping.each{ |key, field| add_field(field, options[key]) }
-          else
-            add_field(mapping, args.last)
-          end
-        end
-      end
-    end
-  end
-end