activemerchant 1.42.6 → 1.90.0

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/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/helper.rb

@@ -1,117 +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 initialize(order, account, options = {})
-          options.assert_valid_keys([:amount, :currency, :test, :credential2, :credential3, :credential4, :country, :account_name, :transaction_type, :authcode])
-          @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]
-        end
-
-        def self.mapping(attribute, options = {})
-          self.mappings ||= {}
-          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

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

@@ -1,58 +0,0 @@
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
-    module Integrations #:nodoc:
-      module HiTrust
-        class Helper < ActiveMerchant::Billing::Integrations::Helper
-          
-          # Transaction types
-          # * Auth
-          # * AuthRe
-          # * Capture
-          # * CaptureRe
-          # * Refund
-          # * RefundRe
-          # * Query
-          def initialize(order, account, options = {})
-            super  
-            # Perform an authorization by default
-            add_field('Type', 'Auth')
-            
-            # Capture the payment right away
-            add_field('depositflag', '1')
-            
-            # Disable auto query - who knows what it does?
-            add_field('queryflag', '1')
-            
-            add_field('orderdesc', 'Store purchase')
-          end
-          
-          mapping :account, 'storeid'
-          mapping :amount, 'amount'
-          
-          def amount=(money)
-            cents = money.respond_to?(:cents) ? money.cents : money 
-
-            if money.is_a?(String) or cents.to_i < 0
-              raise ArgumentError, 'money amount must be either a Money object or a positive integer in cents.' 
-            end
-            
-            add_field(mappings[:amount], cents)
-          end
-          # Supported currencies include:
-          # * CNY：Chinese Yuan (Renminbi)
-          # * TWD：New Taiwan Dollar 
-          # * HKD：Hong Kong Dollar 
-          # * USD：US Dollar 
-          # * AUD：Austrian Dollar 
-          mapping :currency, 'currency'
-        
-          mapping :order, 'ordernumber'
-          mapping :description, 'orderdesc'
-
-          mapping :notify_url, 'merUpdateURL'
-          mapping :return_url, 'returnURL'
-        end
-      end
-    end
-  end
-end

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

@@ -1,59 +0,0 @@
-require 'net/http'
-
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
-    module Integrations #:nodoc:
-      module HiTrust
-        class Notification < ActiveMerchant::Billing::Integrations::Notification
-          SUCCESS = '00'
-          
-          self.production_ips = [ '203.75.242.8' ]
-          
-          def complete?
-            status == 'Completed'
-          end 
-
-          def transaction_id
-            params['authRRN']
-          end
-          
-          def item_id
-            params['ordernumber']
-          end
-          
-          def received_at
-            Time.parse(params['orderdate']) rescue nil
-          end
-          
-          def currency
-            params['currency']
-          end
-
-          def gross
-            sprintf("%.2f", gross_cents.to_f / 100)
-          end
-          
-          def gross_cents
-            params['approveamount'].to_i
-          end
-          
-          def account
-            params['storeid']
-          end
-
-          def status
-            params['retcode'] == SUCCESS ? 'Completed' : 'Failed'
-          end
-          
-          def test?
-            ActiveMerchant::Billing::Base.integration_mode == :test
-          end
-    
-          def acknowledge      
-            true
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,68 +0,0 @@
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
-    module Integrations #:nodoc:
-      module HiTrust
-        class Return < ActiveMerchant::Billing::Integrations::Return
-          SUCCESS = "00"
-          CODES = { "00"   => "Operation completed successfully",
-                    "-1"  => "Unable to initialize winsock dll.",
-                    "-2"  => "Can't create stream socket.",
-                    "-3"  => "No Request Message.",
-                    "-4"  => "Can't connect to server.",
-                    "-5"  => "Send socket error.",
-                    "-6"  => "Couldn't receive data.",
-                    "-7"  => "Receive Broken message.",
-                    "-8"  => "Unable to initialize Envirnment.",
-                    "-9"  => "Can't Read Server RSA File.",
-                    "-10" => "Can't Read Client RSA File.",
-                    "-11" => "Web Server error.",
-                    "-12" => "Receive Message type error.",
-                    "-13" => "No Request Message.",
-                    "-14" => "No Response Content.",
-                    "-18" => "Merchant Update URL not found.",
-                    "-19" => "Server URL not find Domain or IP.",
-                    "-20" => "Server URL only can fill http or https.",
-                    "-21" => "Server Config File open error.",
-                    "-22" => "Server RSA Key File open error.",
-                    "-23" => "Server RSA Key File read error.",
-                    "-24" => "Server Config File have some errors, Please to check it.",
-                    "-25" => "Merchant Config File open error.",
-                    "-26" => "Merchant RSA Key File open error.",
-                    "-27" => "Merchant RSA Key File read error.",
-                    "-28" => "Merchant Config File has some errors, Please to check it.",
-                    "-29" => "Server Type is unknown.",
-                    "-30" => "Comm Type is unknown.",
-                    "-31" => "Input Parameter [ORDERNO] is null or empty.",
-                    "-32" => "Input Parameter [STOREID] is null or empty.",
-                    "-33" => "Input Parameter [ORDERDESC] is null or empty.",
-                    "-34" => "Input Parameter [CURRENCY] is null or empty.",
-                    "-35" => "Input Parameter [AMOUNT] is null or empty.",
-                    "-36" => "Input Parameter [ORDERURL] is null or empty.",
-                    "-37" => "Input Parameter [RETURNURL] is null or empty.",
-                    "-38" => "Input Parameter [DEPOSIT] is null or empty.",
-                    "-39" => "Input Parameter [QUERYFLAG] is null or empty.",
-                    "-40" => "Input Parameter [UPDATEURL] is null or empty.",
-                    "-41" => "Input Parameter [MERUPDATEURL] is null or empty.",
-                    "-42" => "Input Parameter [KEY] is null or empty.",
-                    "-43" => "Input Parameter [MAC] is null or empty.",
-                    "-44" => "Input Parameter [CIPHER] is null or empty.",
-                    "-45" => "Input Parameter [TrxType] is wrong.",
-                    "-100" => "TrustLink Server is closed. Or Merchant Server IP is not consistent with TrustLink Server setting.",
-                    "-101" => "TrustLink Server receives NULL.",
-                    "-308" => "Order Number already exists.",
-                    "positive" => "Response from Bank. Please contact with Acquirer Bank Service or HiTRUST Call Center."
-                  }
-
-          def success?
-            params['retcode'] == SUCCESS
-          end
-
-          def message
-            return CODES["positive"] if params['retcode'].to_i > 0
-            CODES[ params['retcode'] ]
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,27 +0,0 @@
-
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
-    module Integrations #:nodoc:
-      module HiTrust 
-        autoload :Helper, File.dirname(__FILE__) + '/hi_trust/helper.rb'
-        autoload :Return, File.dirname(__FILE__) + '/hi_trust/return.rb'
-        autoload :Notification, File.dirname(__FILE__) + '/hi_trust/notification.rb'
-
-        TEST_URL = 'https://testtrustlink.hitrust.com.tw/TrustLink/TrxReqForJava'
-        LIVE_URL = 'https://trustlink.hitrust.com.tw/TrustLink/TrxReqForJava'
-        
-        def self.service_url
-          ActiveMerchant::Billing::Base.integration_mode == :test ? TEST_URL : LIVE_URL
-        end
-
-        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/ipay88/helper.rb

@@ -1,118 +0,0 @@
-require "digest/sha1"
-
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
-    module Integrations #:nodoc:
-      module Ipay88
-        class Helper < ActiveMerchant::Billing::Integrations::Helper
-          include RequiresParameters
-
-          # Currencies supported
-          #   MYR (Malaysian Ringgit - for all payment methods except China Union Pay and PayPal)
-          #   USD (US Dollar - only for PayPal)
-          #   CNY (Yuan Renminbi - only for China Union Pay)
-          SUPPORTED_CURRENCIES = %w[MYR USD CNY]
-
-          # Languages supported
-          #   ISO-8859-1 (English)
-          #   UTF-8      (Unicode)
-          #   GB2312     (Chinese Simplified)
-          #   GD18030    (Chinese Simplified)
-          #   BIG5       (Chinese Traditional)
-          SUPPORTED_LANGS      = %w[ISO-8859-1 UTF-8 GB2312 GD18030 BIG5]
-
-          # Payment methods supported
-          #   8  (Alliance Online Transfer)
-          #   10 (AmBank)
-          #   21 (China Union Pay)
-          #   20 (CIMB Click)
-          #   2  (Credit Card MYR)
-          #   16 (FPX)
-          #   15 (Hong Leong Bank Transfer)
-          #   6  (Maybank2u.com)
-          #   23 (MEPS Cash)
-          #   17 (Mobile Money)
-          #   33 (PayPal)
-          #   14 (RHB)
-          PAYMENT_METHODS      = %w[8 10 21 20 2 16 15 6 23 17 33 14]
-
-          attr_reader :amount_in_cents, :merchant_key
-
-          def initialize(order, account, options = {})
-            requires!(options, :amount, :currency, :credential2)
-            @merchant_key = options[:credential2]
-            @amount_in_cents = options[:amount]
-            super
-            add_field mappings[:signature], signature
-          end
-
-          def amount_in_dollars
-            sprintf("%.2f", @amount_in_cents.to_f/100)
-          end
-
-          def amount=(money)
-            @amount_in_cents = money.respond_to?(:cents) ? money.cents : money
-            if money.is_a?(String) or @amount_in_cents.to_i < 0
-              raise ArgumentError, "money amount must be either a Money object or a positive integer in cents."
-            end
-            add_field mappings[:amount], amount_in_dollars
-          end
-
-          def currency(symbol)
-            raise ArgumentError, "unsupported currency" unless SUPPORTED_CURRENCIES.include?(symbol)
-            add_field mappings[:currency], symbol
-          end
-
-          def language(lang)
-            raise ArgumentError, "unsupported language" unless SUPPORTED_LANGS.include?(lang)
-            add_field mappings[:language], lang
-          end
-
-          def payment(pay_method)
-            raise ArgumentError, "unsupported payment method" unless PAYMENT_METHODS.include?(pay_method.to_s)
-            add_field mappings[:payment], pay_method
-          end
-
-          def customer(params = {})
-            add_field(mappings[:customer][:name], "#{params[:first_name]} #{params[:last_name]}")
-            add_field(mappings[:customer][:email], params[:email])
-            add_field(mappings[:customer][:phone], params[:phone])
-          end
-
-          def self.sign(str)
-            [Digest::SHA1.digest(str)].pack("m").chomp
-          end
-
-          def signature
-            self.class.sign(self.sig_components)
-          end
-
-          mapping :account,     "MerchantCode"
-          mapping :amount,      "Amount"
-          mapping :currency,    "Currency"
-          mapping :order,       "RefNo"
-          mapping :description, "ProdDesc"
-          mapping :customer, :name  => "UserName",
-                             :email => "UserEmail",
-                             :phone => "UserContact"
-          mapping :remark,      "Remark"
-          mapping :language,    "Lang"
-          mapping :payment,     "PaymentId"
-          mapping :return_url,  "ResponseURL"
-          mapping :signature,   "Signature"
-
-          protected
-
-          def sig_components
-            components  = [merchant_key]
-            components << fields[mappings[:account]]
-            components << fields[mappings[:order]]
-            components << amount_in_dollars.gsub(/[.,]/, '')
-            components << fields[mappings[:currency]]
-            components.join
-          end
-        end
-      end
-    end
-  end
-end