authorizenet_blaq 1.9.3

data/lib/authorize_net/reporting/response.rb

@@ -0,0 +1,163 @@
+module AuthorizeNet::Reporting
+
+  # The CIM response class.
+  class Response < AuthorizeNet::XmlResponse
+    
+    include AuthorizeNet::CIM::Fields
+    
+    # Constructs a new response object from raw_response in the context of transaction.
+    # You don‘t typically construct this object yourself, as AuthorizeNet::Reeporting::Transaction
+    # will build one for you when it makes the request to the gateway.
+    def initialize(raw_response, transaction)
+      super
+      unless connection_failure?
+        begin
+          @batch_list = @root.at_css('batchList')
+          @transactions = @root.at_css('transactions')
+          @transaction = @root.at_css('transaction')
+        rescue
+          @raw_response = $!
+        end
+      end
+    end
+    
+    
+    # Returns an Array of Batch objects built from the entities returned in the response. Returns nil if no batchList was returned.
+    def batch_list
+      unless @batch_list.nil?
+        batches = []
+        @batch_list.element_children.each do |child|
+          batches <<= build_entity(child, Fields::BATCH_ENTITY_DESCRIPTION) unless child.nil?
+        end
+        return batches unless batches.length == 0
+      end
+    end
+    
+    # Returns an Array of TransactionDetail objects built from the entities returned in the response. Returns nil if no transactions were returned.
+    def transactions
+      unless @transactions.nil?
+        transactions = []
+        @transactions.element_children.each do |child|
+          unless child.nil?
+            transaction = build_entity(child, Fields::TRANSACTION_DETAILS_ENTITY_DESCRIPTION)
+            
+            # handle some stuff thats too tricky for EntityDecription to handle
+             first_name = node_content_unless_nil(child.at_css('firstName'))
+            last_name = node_content_unless_nil(child.at_css('lastName'))
+            unless first_name.nil? && last_name.nil?
+              address = AuthorizeNet::Address.new(:first_name => first_name, :last_name => last_name)
+              transaction.customer = AuthorizeNet::Customer.new(:address => address)
+            end
+            invoice_number = node_content_unless_nil(child.at_css('invoiceNumber'))
+            unless invoice_number.nil?
+              transaction.order = AuthorizeNet::Order.new(:invoice_num => invoice_number)
+            end
+            subscription = child.at_css('subscription')
+            unless subscription.nil?
+                subscription_id = node_content_unless_nil(child.at_css('subscription').at_css('id'))
+                transaction.subscription_id = subscription_id unless subscription_id.nil?
+
+                pay_num = node_content_unless_nil(child.at_css('subscription').at_css('payNum'))
+                transaction.subscription_paynum = pay_num unless pay_num.nil?
+            end
+
+
+            transactions <<= transaction
+          end
+        end
+        return transactions unless transactions.length == 0
+      end
+    end
+    
+    # Builds and returns a TransactionDetail entity built from the response. If no transaction was found, returns nil.
+    def transaction
+      unless @transaction.nil?
+        transaction = build_entity(@transaction, Fields::TRANSACTION_DETAILS_ENTITY_DESCRIPTION)
+        
+        ip = node_content_unless_nil(@transaction.at_css('customerIP'))
+        unless ip.nil?
+          transaction.customer ||= AuthorizeNet::CIM::CustomerProfile.new()
+          transaction.customer.ip = ip
+        end
+        
+        tax_exempt = node_content_unless_nil(@transaction.at_css('taxExempt'))
+        unless tax_exempt.nil?
+          transaction.order ||= AuthorizeNet::Order.new()
+          transaction.order.tax_exempt = value_to_boolean(tax_exempt)
+        end
+        
+        tax = @transaction.at_css('tax')
+        unless tax.nil?
+          transaction.order ||= AuthorizeNet::Order.new()
+          tax_amount = node_content_unless_nil(tax.at_css('amount'))
+          transaction.order.tax_amount = value_to_decimal(tax_amount) unless tax_amount.nil?
+          transaction.order.tax_name = node_content_unless_nil(tax.at_css('name'))
+          transaction.order.tax_description = node_content_unless_nil(tax.at_css('description'))
+        end
+        
+        shipping = @transaction.at_css('shipping')
+        unless shipping.nil?
+          transaction.order ||= AuthorizeNet::Order.new()
+          shipping_amount = node_content_unless_nil(shipping.at_css('amount'))
+          transaction.order.shipping_amount = value_to_decimal(shipping_amount) unless shipping_amount.nil?
+          transaction.order.shipping_name = node_content_unless_nil(shipping.at_css('name'))
+          transaction.order.shipping_description = node_content_unless_nil(shipping.at_css('description'))
+        end
+        
+        duty = @transaction.at_css('duty')
+        unless duty.nil?
+          transaction.order ||= AuthorizeNet::Order.new()
+          duty_amount = node_content_unless_nil(duty.at_css('amount'))
+          transaction.order.duty_amount = value_to_decimal(duty_amount) unless duty_amount.nil?
+          transaction.order.duty_name = node_content_unless_nil(duty.at_css('name'))
+          transaction.order.duty_description = node_content_unless_nil(duty.at_css('description'))
+        end
+        
+        line_items = @transaction.at_css('lineItems')
+        unless line_items.nil?
+          transaction.order ||= AuthorizeNet::Order.new()
+          line_items.element_children.each do |child|
+            line_item = build_entity(child, Fields::LINE_ITEM_ENTITY_DESCRIPTION)
+            transaction.order.add_line_item(line_item)
+          end
+        end
+        
+        # Really not sure what to do with customer type here. It should go on a payment
+        customer_type = node_content_unless_nil(@transaction.at_css('customer type'))
+        unless customer_type.nil?
+          transaction.customer ||= AuthorizeNet::CIM::CustomerProfile.new()
+          transaction.customer.payment_profiles = [AuthorizeNet::CIM::PaymentProfile.new(:cust_type => customer_type)]
+        end
+
+        subscription = @transaction.at_css('subscription')
+        unless subscription.nil?
+          subscription_id = node_content_unless_nil(@transaction.at_css('subscription').at_css('id'))
+          transaction.subscription_id = value_to_decimal(subscription_id) unless subscription_id.nil?
+
+          pay_num = node_content_unless_nil(@transaction.at_css('subscription').at_css('payNum'))
+          transaction.subscription_paynum = value_to_decimal(pay_num) unless pay_num.nil?
+        end
+
+        solution = @transaction.at_css('solution')
+        unless solution.nil?
+          solution_id = node_content_unless_nil(@transaction.at_css('solution').at_css('id'))
+          transaction.solution_id = value_to_decimal(solution_id) unless solution_id.nil?
+
+          transaction.solution_name = node_content_unless_nil(@transaction.at_css('solution').at_css('name'))
+        end
+
+        returned_items = @transaction.at_css('returnedItems')
+        unless returned_items.nil?
+          transaction.returns ||= AuthorizeNet::Reporting::ReturnedItem.new
+          returned_items.element_children.each do |child|
+            returned_item = build_entity(child, Fields::RETURNED_ITEM_ENTITY_DESCRIPTION)
+            transaction.returns.add_returned_item(returned_item)
+          end
+        end
+
+        return transaction
+      end
+    end
+    
+  end
+end

data/lib/authorize_net/reporting/returned_item.rb

@@ -0,0 +1,46 @@
+module AuthorizeNet::Reporting
+
+  class ReturnedItem
+    include AuthorizeNet::Model
+
+    attr_accessor :id, :date_utc, :date_local, :code, :description, :returned_items
+
+    def date_utc=(time)
+      if time.kind_of?(DateTime)
+        @date_utc = time
+      else
+        @date_utc = DateTime.parse(time.to_s)
+      end
+    end
+
+    def date_local=(time)
+      if time.kind_of?(DateTime)
+        @date_local = time
+      else
+        @date_local = DateTime.parse(time.to_s)
+      end
+    end
+
+    def add_returned_item(id = nil, date_utc = nil, date_local = nil, code = nil, description = nil)
+      if id.kind_of?(AuthorizeNet::Reporting::ReturnedItem)
+        returned_item = id
+      else
+        returned_item = AuthorizeNet::Reporting::ReturnedItem.new({:return_item_id => id, :return_item_date_utc => date_utc, :return_item_date_local => date_local, :return_item_code => code, :line_item_description => description})
+      end
+      @returned_items = @returned_items.to_a << returned_item
+    end
+
+    def to_hash
+      hash = {
+          :id => @id,
+          :date_utc => @date_utc,
+          :date_local => @date_local,
+          :code => @code,
+          :description => @description,
+          :returned_items => handle_multivalue_hashing(@returned_items)
+      }
+      hash.delete_if { |k, v| v.nil? }
+      hash
+    end
+  end
+end

data/lib/authorize_net/reporting/transaction.rb

@@ -0,0 +1,133 @@
+module AuthorizeNet::Reporting
+
+  # The Reporting API transaction class.
+  class Transaction < AuthorizeNet::XmlTransaction
+    
+    include AuthorizeNet::Reporting::Fields
+    
+    # The class to wrap our response in.
+    @response_class = AuthorizeNet::Reporting::Response
+    
+    # Fields to convert to/from Date.
+    @@datetime_fields = [:first_settlement_date, :last_settlement_date]
+    
+    # Constructs a Reporting transaction. You can use the new Reporting transaction object
+    # to issue a request to the payment gateway and parse the response into a new
+    # AuthorizeNet::Reporting::Response object.
+    # 
+    # +api_login_id+:: Your API login ID, as a string.
+    # +api_transaction_key+:: Your API transaction key, as a string.
+    # +options+:: A hash of options. See below for values.
+    # 
+    # Options
+    # +gateway+:: The gateway to submit the transaction to. Can be a URL string, an AuthorizeNet::Reporting::Transaction::Gateway constant, or one of the convenience symbols :sandbox, :test, :production, or :live (:test is an alias for :sandbox, and :live is an alias for :production). 
+    # +verify_ssl+:: A boolean indicating if the SSL certificate of the +gateway+ should be verified. Defaults to true.
+    # +reference_id+:: A string that can be used to identify a particular transaction with its response. Will be echo'd in the response, only if it was provided in the transaction. Defaults to nil.
+    #
+    def initialize(api_login_id, api_transaction_key, options = {})
+      super
+    end
+    
+    # Sets up and submits a getSettledBatchListRequest transaction. If this transaction has already been
+    # run, this method will return nil. Otherwise it will return an AuthorizeNet::Reporting::Response object. The
+    # response object will have an array of Batch objects available via its batch_list method if
+    # the request was successful.
+    # 
+    #
+    # +from_date+:: Takes either a DateTime or a String representing a date and time. Only settled batches >= this value will be returned. Defaults to nil (which returns >= 24hrs ago). A to_date must be specified if a from_date is.
+    # +to_date+:: Takes either a DateTime or a String representing a date and time. Only settled batches <= this value will be returned. Defaults to nil. The maximum date range is 31 days, and a from_date must be supplied if a to_date is.
+    # +include_stats+:: Takes a Boolean. Determines if BatchStatistics should be returned with the Batch objects. Defaults to false.
+    #
+    # Typical usage:
+    # 
+    #   response = transaction.get_settled_batch_list(DateTime.now() - (1 * 3600 * 48), DateTime.now(), true)
+    #   batches = response.batch_list if response.success?
+    #
+    def get_settled_batch_list(from_date = nil, to_date = nil, include_stats = false)
+      @type = Type::REPORT_GET_BATCH_LIST
+      set_fields({:first_settlement_date => from_date, :last_settlement_date => to_date, :include_statistics => include_stats})
+      make_request
+    end
+    
+    # Sets up and submits a getTransactionListRequest transaction. If this transaction has already been
+    # run, this method will return nil. Otherwise it will return an AuthorizeNet::Reporting::Response object. The
+    # response object will have an array of TransactionDetail objects available via its transactions method if
+    # the request was successful. These TransactionDetail objects will not be fully populated. Use get_transaction_details
+    # to get all the details.
+    # 
+    #
+    # +batch_id+:: Takes either a Batch object with its id attribute populated, or a String representing the ID of the batch to retrieve the transaction list from.
+    #
+    # Typical usage:
+    # 
+    #   response = transaction.get_transaction_list('123456')
+    #   transactions = response.transactions if response.success?
+    #
+    def get_transaction_list(batch_id)
+      @type = Type::REPORT_GET_TRANSACTION_LIST
+      handle_batch_id(batch_id)
+      make_request
+    end
+    
+    # Sets up and submits a getUnsettledTransactionListRequest transaction. If this transaction has already been
+    # run, this method will return nil. Otherwise it will return an AuthorizeNet::Reporting::Response object. The
+    # response object will have an array of TransactionDetail objects available via its transactions method if
+    # the request was successful. These TransactionDetail objects will not be fully populated. Use get_transaction_details
+    # to get all the details.
+    # 
+    #
+    # Typical usage:
+    # 
+    #   response = transaction.get_unsettled_transaction_list
+    #   transactions = response.transactions if response.success?
+    #
+    def get_unsettled_transaction_list
+      @type = Type::REPORT_GET_UNSETTLED_TRANSACTION_LIST
+      make_request
+    end
+
+    # Sets up and submits a getTransactionDetailsRequest transaction. If this transaction has already been
+    # run, this method will return nil. Otherwise it will return an AuthorizeNet::Reporting::Response object. The
+    # response object will have a TransactionDetail object available via its transactions method if
+    # the request was successful. This TransactionDetail object will have more data than the limited version
+    # returned by get_transaction_list.
+    # 
+    #
+    # +transaction_id+:: Takes either a TransactionDetail object with its id attribute populated, or a String representing the ID of the transaction to retrieve the details from.
+    #
+    # Typical usage:
+    # 
+    #   response = transaction.get_transaction_details('123456789')
+    #   transactions = response.transactions if response.success?
+    #
+    def get_transaction_details(transaction_id)
+      @type = Type::REPORT_GET_TRANSACTION_DETAILS
+      handle_transaction_id(transaction_id)
+      make_request
+    end
+    
+    #:enddoc:
+    protected
+    
+    # Handles batch id type massaging.
+    def handle_batch_id(id)
+      case id
+      when Batch
+        set_fields(:batch_id => id.id.to_s)
+      else
+        set_fields(:batch_id => id.to_s)
+      end
+    end
+    
+    # Handles transaction id type massaging.
+    def handle_transaction_id(id)
+      case id
+      when TransactionDetails
+        set_fields(:transaction_id => id.id.to_s)
+      else
+        set_fields(:transaction_id => id.to_s)
+      end
+    end
+  end
+  
+end

data/lib/authorize_net/reporting/transaction_details.rb

@@ -0,0 +1,25 @@
+module AuthorizeNet::Reporting
+
+  # Models the details of a transaction.
+  class TransactionDetails
+    
+    include AuthorizeNet::Model
+
+    attr_accessor :id, :submitted_at, :status, :order, :customer, :account_type,
+                  :account_number, :settle_amount, :reference_id, :split_tender_id,
+                  :type, :response_code, :response_reason_code, :response_reason_description,
+                  :auth_code, :avs_response, :card_code_response, :cavv_response,
+                  :fds_filter_action, :fds_filters, :batch, :prepaid_balance_remaining,
+                  :payment_method, :recurring_billing, :bill_to, :ship_to, :auth_amount,
+                  :subscription_id, :subscription_paynum, :solution_id, :solution_name, :returns
+    
+    def submitted_at=(time)
+      if time.kind_of?(DateTime)
+        @submitted_at = time
+      else
+        @submitted_at = DateTime.parse(time.to_s)
+      end
+    end
+
+  end
+end

data/lib/authorize_net/response.rb

@@ -0,0 +1,27 @@
+module AuthorizeNet
+  
+  # The core, API agnostic response class. You shouldn't instantiate this one.
+  # Instead you should use AuthorizeNet::AIM::Response, AuthorizeNet::ARB::Response or AuthorizeNet::SIM::Response.
+  class Response
+    
+    include AuthorizeNet::TypeConversions
+        
+    # Fields to convert to/from booleans.
+    @@boolean_fields = []
+
+    # Fields to convert to/from BigDecimal.
+    @@decimal_fields = []
+    
+    # DO NOT USE. Instantiate AuthorizeNet::AIM::Response or AuthorizeNet::SIM::Response instead.
+    def initialize()
+      raise "#{self.class.to_s} should not be instantiated directly."
+    end
+    
+    # Check to see if the response indicated success.
+    def success?
+      false
+    end
+    
+  end
+  
+end

data/lib/authorize_net/sim/hosted_payment_form.rb

@@ -0,0 +1,38 @@
+module AuthorizeNet::SIM
+  
+  # Models a hosted payment form.
+  class HostedPaymentForm
+    
+    include AuthorizeNet::Model
+    
+    attr_accessor :header_html, :footer_html, :color_background, :color_link, :color_text, :logo_url, :background_url, :rename
+    
+    # Convenience method for adding field rename requests to the transaction. This renames a field shown on
+    # the hosted payment form.
+    def add_rename(field, name)
+      rename = "#{field},#{name}"
+      unless @rename.nil?
+        @rename = @rename.to_a << rename
+      else
+        @rename = [rename]
+      end
+    end
+    
+    def to_hash
+      hash = {
+        :header_html_payment_form => @header_html,
+        :footer_html_payment_form => @footer_html,
+        :color_background => @color_background,
+        :color_link => @color_link,
+        :color_text => @color_text,
+        :logo_url => @logo_url,
+        :background_url => @background_url,
+        :rename => @rename
+      }
+      hash.delete_if {|k, v| v.nil?}
+      hash
+    end
+  
+  end
+  
+end

data/lib/authorize_net/sim/hosted_receipt_page.rb

@@ -0,0 +1,37 @@
+module AuthorizeNet::SIM
+  
+  # Models a hosted receipt page.
+  class HostedReceiptPage
+    
+    # Defines constants for each of the link methods used by the hosted receipt page.
+    module LinkMethod
+      LINK = 'LINK'
+      POST = 'POST'
+      GET = 'GET'
+    end
+    
+    include AuthorizeNet::Model
+    
+    attr_accessor :header_html, :footer_html, :color_background, :color_link, :color_text, :logo_url, :background_url, :link_method, :link_text, :link_url
+    
+    
+    def to_hash
+      hash = {
+        :header_html_receipt => @header_html,
+        :footer_html_receipt => @footer_html,
+        :color_background => @color_background,
+        :color_link => @color_link,
+        :color_text => @color_text,
+        :logo_url => @logo_url,
+        :background_url => @background_url,
+        :receipt_link_method => @link_method,
+        :receipt_link_text => @link_text,
+        :receipt_link_url => @link_url
+      }
+      hash.delete_if {|k, v| v.nil?}
+      hash
+    end
+  
+  end
+  
+end

data/lib/authorize_net/sim/response.rb

@@ -0,0 +1,142 @@
+module AuthorizeNet::SIM
+  
+  # The SIM response class. Handles parsing the response from the gateway. Also
+  # provides a few relay response helpers used to implement Direct Post Method.
+  class Response < AuthorizeNet::KeyValueResponse
+    
+    # Our MD5 digest generator.
+    @@digest = OpenSSL::Digest.new('md5')
+
+    include AuthorizeNet::SIM::Fields
+    
+    # Constructs a new response object from a +raw_response+. Provides utility methods
+    # for validating the response as authentic, and for handling the Direct Post Method
+    # relay response.
+    # 
+    # +raw_response+:: The raw response, either a string in POST body or GET query string format, or a hash of key/value pairs.
+    # 
+    # Typical usage:
+    #   response = AuthorizeNet::SIM::Response("x_first_name=John&x_last_name=Doe")
+    def initialize(raw_response)
+      @raw_response = raw_response
+      @custom_fields = {}
+      @fields = {}
+      parse_response(@raw_response)
+    end
+    
+    
+    # Returns True if the MD5 hash found in the response payload validates using
+    # the supplied api_login and secret merchant_value (THIS IS NOT YOUR API KEY).
+    def valid_md5?(api_login, merchant_value)
+      if @fields[:MD5_Hash].nil?
+        return false
+      end
+      @@digest.hexdigest("#{merchant_value}#{api_login}#{@fields[:trans_id]}#{@fields[:amount]}").downcase == @fields[:MD5_Hash].downcase
+    end
+    
+    # Returns an HTML string that can be returned to the gateway during the Relay Response,
+    # and will send the user on to URL you specify. Takes a hash of options, currently the
+    # only option is :include, which can be True to include all fields returned in the response
+    # as query string parameters, or it can be an array of fields to include.
+    def direct_post_reply(url, options = {})
+      url = direct_post_url(url, options[:include]) if options.has_key?(:include)
+      js_url = url.gsub("'", '\'')
+      html_url = url.gsub('&', '&amp;').gsub('"', "\"")
+      html = <<-HTML
+<html><head><script type="text/javascript" charset="utf-8">window.location='#{js_url}';</script><noscript><meta http-equiv="refresh" content="1;url=#{html_url}"></noscript></head><body></body></html>
+HTML
+    end
+    
+    # Returns an URL with the fields found in the response and specified in include_fields attached as
+    # part of the URL's query string. If you pass true instead of an array of fields, all fields will be
+    # attached.
+    def direct_post_url(base_url, include_fields = true)
+      url = base_url
+      if include_fields
+        fields = []
+        case include_fields
+        when TrueClass
+          fields = FIELDS.collect do |k|
+            k_str = k.to_s
+            k_str[2..k_str.length].to_sym
+          end
+        when Array
+          fields = include_fields
+        else
+          fields = include_fields.to_a
+        end
+        parsed_url = URI.parse(url)
+        if parsed_url.query.nil?
+          parsed_url.query = ''
+        elsif parsed_url.query.length != 0
+          parsed_url.query = parsed_url.query.chomp('&') + '&'
+        end
+        parsed_url.query += ((fields.select { |k| @fields.has_key?(k) }).collect { |k| self.to_param(k, @fields[k]) }).join('&')
+        parsed_url.query.chomp('&')
+        url = parsed_url.to_s
+      end
+      url
+    end
+    
+    # Check to see if the response indicated success. Success is defined as a valid MD5 hash
+    # and an response code of AuthorizeNet::Response::ResponseCode::APPROVED.
+    def success?(api_login, merchant_value)
+      valid_md5?(api_login, merchant_value) && approved?
+    end
+    
+    # Returns the transaction's authorization code. This should be shown to the
+    # end user.
+    def authorization_code
+      @fields[:auth_code]
+    end
+    
+    # Returns the transaction's authorization id. You will need this for future void, refund
+    # and prior authorization capture requests.
+    def transaction_id
+      @fields[:trans_id]
+    end
+    
+    # Returns the customer id from the response.
+    def customer_id
+      @fields[:cust_id]
+    end
+    
+    # Returns a response code (from AVSResponseCode) indicating the result of any Address Verification
+    # Service checks. 
+    def avs_response
+      @fields[:avs_code]
+    end
+    
+    #:enddoc:
+    protected
+    
+    # Internal helper to parse the raw response object. It handles both raw POST bodies and
+    # hashes.
+    def parse_response(raw_response)
+      case raw_response
+      when Hash
+        raw_response.each do |k, v|
+          k = k.to_sym
+          if FIELDS.include?(k)
+            @fields[to_internal_field(k)] = v # remove x_ from sym and stick in @fields
+          else
+            @custom_fields[k] = v
+          end
+        end
+      when String
+        # convert to hash and re-parse
+        hash = CGI::parse(raw_response)
+        hash.each do |k, v|
+          if v.kind_of?(Array) && v.length == 1
+            hash[k] = v[0]
+          end
+        end
+        parse_response(hash)
+      else
+        parse_response(@raw_response.to_s)
+      end
+    end
+    
+  end
+
+end