yetanothernguyen-activemerchant 1.16.0 → 1.21.0

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

@@ -0,0 +1,340 @@
+require 'net/http'
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    module Integrations #:nodoc:
+      
+      # # Example:
+      # parser = AuthorizeNetSim::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 => 'authorize_net_sim_payment_response'
+      # end
+      #       
+      # if order.total != parser.gross.to_f
+      #   logger.error "Authorize.Net sim said they paid for #{parser.gross} and it should have been #{order.total}!"
+      #   passed = false
+      # end
+      # 
+      # # Theoretically, Authorize.net 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 MD5_HASH_SET_IN_AUTHORIZE_NET, AUTHORIZE_LOGIN
+      #  passed = false
+      #  logger.error "ALERT POSSIBLE FRAUD ATTEMPT either that or you haven't setup your md5 hash setting right in #{__FILE__} 
+      #    because a transaction came back from Authorize.Net with the wrong hash value--rejecting!"
+      # 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 AuthorizeNetSim
+        class Notification < ActiveMerchant::Billing::Integrations::Notification
+
+          def unescape(val) #:nodoc:
+            if val
+              CGI::unescape val
+            else
+              val
+            end
+          end
+
+          # Passes a hash of the address the user entered in at Authorize.Net
+          def billing_address
+            all = {}
+            [:fax, :city, :company, :last_name, :country, :zip, :first_name, :address, :email, :state].each do |key_out|
+              all[key_out] = unescape params['x_' + key_out.to_s]
+            end
+            all
+          end
+
+          def customer_id
+            unescape params['x_cust_id']
+          end
+
+          def auth_code
+            unescape params['x_auth_code']
+          end
+
+          def po_num
+           unescape params['x_po_num']
+          end
+
+          def ship_to_address
+           all = {}
+            [:city, :last_name, :first_name, :country, :zip, :address].each do |key_out|
+              all[key_out] = unescape params['x_ship_to_' + key_out.to_s]
+            end
+            all
+          end
+
+          # Tax amount we sent them.
+          def tax
+            unescape params['x_tax']
+          end
+          
+          # Transaction type (probably going to be auth_capture, since that's
+          # all we set it as).
+          def transaction_type
+            unescape params['x_type'] 
+          end
+          
+          # Payment method used--almost always CC (for credit card).
+          def method
+            unescape params['x_method']
+          end
+          
+          # Ff our payment method is available. Almost always "true".
+          def method_available
+            params['x_method_available']
+          end
+          
+          # Invoice num we passed in as invoice_num to them.
+          def invoice_num
+            item_id
+          end
+          
+          # If you pass any values to authorize that aren't its expected, it
+          # will pass them back to you verbatim, returned by this method.
+          # custom values:
+          def all_custom_values_passed_in_and_now_passed_back_to_us
+            all = {}
+            params.each do |key, value|
+              if key[0..1] != 'x_'
+                all[key] = unescape value
+              end
+            end
+            all
+          end
+          
+          def duty
+            unescape params['x_duty']
+          end
+          
+          # Shipping we sent them.
+          def freight
+            unescape params['x_freight']
+          end
+          alias_method :shipping, :freight
+                    
+          def description
+            unescape params['x_description']
+          end
+          
+          # Returns the response code as a symbol.
+          # {'1' => :approved, '2' => :declined, '3' => :error, '4' => :held_for_review}
+          def response_code_as_ruby_symbol
+            map = {'1' => :approved, '2' => :declined, '3' => :error, '4' => :held_for_review}
+            map[params['x_response_code']]
+          end
+          
+          def response_reason_text
+            unescape params['x_response_reason_text']
+          end
+          
+          # The response reason text's numeric id [equivalent--just a number]
+          def response_reason_code
+            unescape params['x_response_reason_code']
+          end
+          
+          # 'used internally by their gateway'
+          def response_subcode
+            params['x_response_subcode']
+          end
+          
+          # They pass back a tax_exempt value.
+          def tax_exempt
+            params['x_tax_exempt']
+          end
+            
+          # avs [address verification] code
+          # A = Address (Street) 
+          # matches, ZIP does not 
+          # B = Address information 
+          # not provided for AVS 
+          # check 
+          # E = AVS error 
+          # G = Non-U.S. Card Issuing
+          # Bank 
+          # N = No Match on Address 
+          # (Street) or ZIP 
+          # P = AVS not applicable for
+          # this transaction 
+          # R = Retry – System 
+          # unavailable or timed out 
+          # S = Service not supported
+          # by issuer 
+          # U = Address information is
+          # unavailable 
+          # W = Nine digit ZIP 
+          # matches, Address (Street)
+          # does not 
+          # X = Address (Street) and 
+          # nine digit ZIP match 
+          # Y = Address (Street) and 
+          # five digit ZIP match 
+          # Z = Five digit ZIP matches
+          # Address (Street) does not
+          def avs_code
+            params['x_avs_code']
+          end
+          
+          # Returns true if their address completely matched [Y or X, P from
+          # #avs_code, which mean 'add+zip match', 'address + 9-zip match', and
+          # not applicable, respectively].
+          def avs_code_matches?
+            return ['Y', 'X', 'P'].include? params['x_avs_code']
+          end
+          
+          # cvv2 response
+          # M = Match 
+          # N = No Match 
+          # P = Not Processed 
+          # S = Should have been 
+          # present 
+          # U = Issuer unable to 
+          # process request 
+          def cvv2_resp_code
+            params['x_cvv2_resp_code']
+          end
+          
+          # check if #cvv2_resp_code == 'm' for Match.  otherwise false
+          def cvv2_resp_code_matches?
+            return ['M'].include? cvv2_resp_code
+          end
+
+          # cavv_response--'cardholder authentication verification response code'--most likely not use for SIM
+          # Blank or not present  =  
+          # CAVV not validated 
+          # 0 = CAVV not validated 
+          # because erroneous data 
+          # was submitted 
+          # 1 = CAVV failed validation
+          # 2 = CAVV passed 
+          # validation 
+          # 3 = CAVV validation could
+          # not be performed; issuer 
+          # attempt incomplete 
+          # 4 = CAVV validation could
+          # not be performed; issuer 
+          # system error 
+          # 5 = Reserved for future 
+          # use 
+          # 6 = Reserved for future 
+          # use 
+          # 7 = CAVV attempt – failed
+          # validation – issuer 
+          # available (U.S.-issued 
+          # card/non-U.S acquirer) 
+          # 8 = CAVV attempt – 
+          # passed validation – issuer
+          # available (U.S.-issued 
+          # card/non-U.S. acquirer) 
+          # 9 = CAVV attempt – failed
+          # validation – issuer 
+          def cavv_response
+            params['x_cavv_response']
+          end
+          
+          # Check if #cavv_response == '', '2', '8' one of those [non failing]
+          # [blank means no validated, 2 is passed, 8 is passed issuer
+          # available]
+          def cavv_matches?
+            ['','2','8'].include? cavv_response
+          end
+           
+          # Payment is complete -- returns true if x_response_code == '1'
+          def complete?
+            params["x_response_code"] == '1'
+          end 
+
+          # Alias for invoice number--this is the only id they pass back to us
+          # that we passed to them, except customer id is also passed back.
+          def item_id
+            unescape params['x_invoice_num']
+          end
+
+          # They return this number to us [it's unique to Authorize.net].
+          def transaction_id
+            params['x_trans_id']
+          end
+
+          # When was this payment was received by the client. --unimplemented --
+          # always returns nil
+          def received_at
+            nil
+          end
+
+          # End-user's email
+          def payer_email
+            unescape params['x_email']
+          end
+
+          # They don't pass merchant email back to us -- unimplemented -- always
+          # returns nil
+          def receiver_email
+            nil
+          end 
+
+          # md5 hash used internally
+          def security_key
+            params['x_MD5_Hash']
+          end
+
+          # The money amount we received in X.2 decimal. Returns a string
+          def gross
+            unescape params['x_amount']
+          end
+
+          # Was this a test transaction?
+          def test?
+            params['x_test_request'] == 'true'
+          end
+
+          # #method_available alias
+          def status
+            complete?
+          end
+
+          # Called to request back and check if it was a valid request.
+          # Authorize.net passes us back a hash that includes a hash of our
+          # 'unique' MD5 value that we set within their system.
+          #
+          # Example: 
+          # acknowledge('my secret md5 hash that I set within Authorize.Net', 'authorize_login')
+          #
+          # Note this is somewhat unsafe unless you actually set that md5 hash
+          # to something (defaults to '' in their system).
+          def acknowledge(md5_hash_set_in_authorize_net, authorize_net_login_name)
+            Digest::MD5.hexdigest(md5_hash_set_in_authorize_net + authorize_net_login_name + params['x_trans_id'] + gross) == params['x_MD5_Hash'].downcase
+          end
+          
+         private
+
+          # Take the posted data and move the relevant data into a hash.
+          def parse(post)
+            @raw = post
+            post.split('&').each do |line|
+              key, value = *line.scan( %r{^(\w+)\=(.*)$} ).flatten
+              params[key] = value
+            end
+          end
+          
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    module Integrations #:nodoc:
+      module AuthorizeNetSim 
+        autoload :Helper, 'active_merchant/billing/integrations/authorize_net_sim/helper.rb'
+        autoload :Notification, 'active_merchant/billing/integrations/authorize_net_sim/notification.rb'
+
+        # Overwrite this if you want to change the ANS test url
+        mattr_accessor :test_url
+        self.test_url = 'https://test.authorize.net/gateway/transact.dll'
+        
+        # Overwrite this if you want to change the ANS production url
+        mattr_accessor :production_url 
+        self.production_url = 'https://secure.authorize.net/gateway/transact.dll' 
+        
+        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/direc_pay/helper.rb

@@ -173,15 +173,15 @@ module ActiveMerchant #:nodoc:
           end
           
           def encode_value(value)
-            encoded = ActiveSupport::Base64.encode64s(value)
+            encoded = Base64.strict_encode64(value)
             string_to_encode = encoded[0, 1] + "T" + encoded[1, encoded.length]
-            ActiveSupport::Base64.encode64s(string_to_encode)
+            Base64.strict_encode64(string_to_encode)
           end
           
           def decode_value(value)
-            decoded = ActiveSupport::Base64.decode64(value)
+            decoded = Base64.decode64(value)
             string_to_decode = decoded[0, 1] + decoded[2, decoded.length]
-            ActiveSupport::Base64.decode64(string_to_decode)
+            Base64.decode64(string_to_decode)
           end
           
           def phone_code_for_country(country)

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

@@ -0,0 +1,31 @@
+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
+          
+          # 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'          
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+require 'net/http'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    module Integrations #:nodoc:
+      module Dwolla
+        class Notification < ActiveMerchant::Billing::Integrations::Notification
+          def complete?
+            status == "Completed"
+          end
+
+          def status
+            params["Status"]
+          end
+
+          def transaction_id
+            params['TransactionId']
+          end
+
+          def item_id
+            params['OrderId']
+          end
+
+          def currency
+            "USD"
+          end
+
+          def gross
+            params['Amount']
+          end
+
+          def error
+            params['Message']
+          end
+
+          # Was this a test transaction?
+          def test?
+            params['TestMode']
+          end
+
+          def acknowledge      
+            true
+          end
+ private
+          # Take the posted data and move the relevant data into a hash
+          def parse(post)
+            @raw = post.to_s
+            json_post = JSON.parse(post)
+            params.merge!(json_post)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    module Integrations #:nodoc:
+      module Dwolla
+        class Return < ActiveMerchant::Billing::Integrations::Return
+
+          def success?
+            self.error.nil? && self.callback_success?
+          end
+
+          def error
+            params['error']
+          end
+
+          def error_description
+            params['error_description']
+          end
+
+          def checkout_id
+            params['checkoutid']
+          end
+
+          def transaction
+            params['transaction']
+          end
+
+          def test?
+            params['test']
+          end
+
+          def callback_success?
+            params['postback'] != "failure"
+          end
+	      end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# 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 
+        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'
+       
+        mattr_accessor :service_url
+        self.service_url = 'https://www.dwolla.com/payment/pay'
+
+        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

@@ -14,8 +14,10 @@ module ActiveMerchant #:nodoc:
         self.application_id = 'ActiveMerchant'
 
         def initialize(order, account, options = {})
-          options.assert_valid_keys([:amount, :currency, :test, :credential2, :credential3, :credential4, :country, :account_name])
-          @fields = {}
+          options.assert_valid_keys([:amount, :currency, :test, :credential2, :credential3, :credential4, :country, :account_name, :transaction_type])
+          @fields          = {}
+          @raw_html_fields = []
+          @test            = options[:test]
           self.order       = order
           self.account     = account
           self.amount      = options[:amount]
@@ -42,6 +44,17 @@ module ActiveMerchant #:nodoc:
           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
@@ -54,6 +67,10 @@ module ActiveMerchant #:nodoc:
           @fields
         end
 
+        def test?
+          @test_mode ||= ActiveMerchant::Billing::Base.integration_mode == :test || @test
+        end
+
         private
         
         def add_address(key, params)