authorizenet 1.8

data/lib/authorize_net/payment_methods/credit_card.rb

@@ -0,0 +1,74 @@
+module AuthorizeNet
+  
+  # Defines constants for each payment method type.
+  module PaymentMethodType
+    CREDIT_CARD = 'CC'
+  end
+  
+  # Models a credit card.
+  class CreditCard
+    PAYMENT_METHOD_CODE = AuthorizeNet::PaymentMethodType::CREDIT_CARD
+    
+    # The option defaults for the constructor.
+    @@option_defaults = {
+      :card_code => nil,
+      :card_type => nil
+    }
+    
+    attr_accessor :card_number, :expiration, :card_code, :card_type, :track_1, :track_2
+    
+    # Constructs a new credit card object. Takes a credit card number
+    # and an expiration date. The CCV code can be passed as an option. So can
+    # the data tracks (1 & 2). When passing in data tracks, please pass the
+    # whole track. Sentinels and the LRC will be removed by the SDK. Track data
+    # must be passed along as ASCII. The raw bit stream from the card is not acceptable.
+    # 
+    # Field separators on
+    # 
+    # +card_number+:: The credit card number as a string.
+    # +expiration+:: The credit card expiration date as a string with format MMYY.
+    # +options+:: A hash of options.
+    # 
+    # Options
+    # +card_code+:: Sets the CCV code for the credit card.
+    # +card_type+:: Sets the type of card (Visa, MasterCard, Dinners Club, etc.)
+    # +track_1+:: Sets the track 1 data. Either track 1 or track 2 data needs to be included for card present transactions (otherwise fee structure will change).
+    # +track_2+:: Sets the track 2 data. Either track 1 or track 2 data needs to be included for card present transactions (otherwise fee structure will change).
+    #
+    # 
+    def initialize(card_number, expiration, options = {})
+      @card_number = card_number
+      @expiration = expiration
+      options = @@option_defaults.merge(options)
+      @card_code = options[:card_code]
+      @card_type = options[:card_type]
+      @track_1 = options[:track_1]
+      @track_2 = options[:track_2]
+    end
+    
+    def to_hash
+      hash = {
+        :method => PAYMENT_METHOD_CODE,
+        :card_num => @card_number,
+        :exp_date => @expiration
+      }
+      hash[:card_code] = @card_code unless @card_code.nil?
+      unless @track_1.nil?
+        track_1 = @track_1
+        if track_1[0..0] == '%'
+          track_1 = track_1[1..(@track_1.rindex('?') - 1)]
+        end
+        hash[:track1] = track_1
+      end
+      unless @track_2.nil?
+        track_2 = @track_2
+        if track_2[0..0] == ';'
+          track_2 = track_2[1..(@track_2.rindex('?') - 1)]
+        end
+        hash[:track2] = track_2
+      end
+      hash
+    end
+    
+  end
+end

data/lib/authorize_net/payment_methods/echeck.rb

@@ -0,0 +1,72 @@
+module AuthorizeNet
+  
+  # Defines constants for each payment method type.
+  module PaymentMethodType
+    ECHECK = 'ECHECK'
+  end
+  
+  # Models an eCheck.
+  class ECheck
+    PAYMENT_METHOD_CODE = AuthorizeNet::PaymentMethodType::ECHECK
+    
+    # Defines constants for each bank account type.
+    module AccountType
+      CHECKING = 'CHECKING'
+      SAVINGS = 'SAVINGS'
+      BUSINESS_CHECKING = 'BUSINESSCHECKING'
+    end
+    
+    # Defines constants for each check type.
+    module CheckType
+      ACCOUNTS_RECEIVABLE_CONVERSION = 'ARC'
+      BACK_OFFICE_CONVERSION = 'BOC'
+      CASH_CONCENTRATION_DISBURSEMENT = 'CCD'
+      PREARRANGED_PAYMENT_DEPOSIT = 'PPD'
+      TELEPHONE_INITIATED = 'TEL'
+      INTERNET_INITIATED = 'WEB'
+    end
+    
+    # The option defaults for the constructor.
+    @@option_defaults = {
+      :echeck_type => CheckType::INTERNET_INITIATED,
+      :check_number => nil,
+      :account_type => AccountType::CHECKING
+    }
+    
+    attr_accessor :routing_number, :account_number, :bank_name, :account_holder_name, :echeck_type, :check_number, :account_type
+    
+    # Constructs a new eCheck object.
+    # 
+    # +routing_number+:: The bank routing number as a string.
+    # +account_number+:: The bank account number as a string.
+    # +bank_name+:: The legal name of the bank. This should match the name associated with the +routing_number+.
+    # +account_holder_name+:: The full name on the bank account represented by +account_number+.
+    # +options+:: A hash of options. Accepts +echeck_type+ (the type of check, can usually be ignored), +check_number+ (the number on the check, only needed for some check types), and +account_type+ (the type of bank account the check draws from). All values should be passed as strings.
+    #
+    def initialize(routing_number, account_number, bank_name, account_holder_name, options = {})
+      @routing_number = routing_number
+      @account_number = account_number
+      @bank_name = bank_name
+      @account_holder_name = account_holder_name
+      options = @@option_defaults.merge(options)
+      @echeck_type = options[:echeck_type]
+      @check_number = options[:check_number]
+      @account_type = options[:account_type]
+    end
+    
+    def to_hash
+      hash = {
+        :method => PAYMENT_METHOD_CODE,
+        :bank_aba_code => @routing_number,
+        :bank_acct_num => @account_number,
+        :bank_acct_type => @account_type,
+        :bank_name => @bank_name,
+        :bank_acct_name => @account_holder_name,
+        :echeck_type => @echeck_type
+      }
+      hash[:bank_check_number] = @check_number unless @check_number.nil?
+      hash
+    end
+  end
+  
+end

data/lib/authorize_net/reporting/batch.rb

@@ -0,0 +1,19 @@
+module AuthorizeNet::Reporting
+
+  # Models a batch of credit cards.
+  class Batch
+    
+    include AuthorizeNet::Model
+    
+    attr_accessor :id, :settled_at, :state, :statistics, :payment_method
+    
+    def settled_at=(time)
+      if time.kind_of?(DateTime)
+        @settled_at = time
+      else
+        @settled_at = DateTime.parse(time.to_s)
+      end
+    end
+  end
+
+end

data/lib/authorize_net/reporting/batch_statistics.rb

@@ -0,0 +1,19 @@
+module AuthorizeNet::Reporting
+
+  # Models a batch of credit cards.
+  class BatchStatistics
+    
+    include AuthorizeNet::Model
+    
+    attr_accessor :account_type, :charge_count, :charge_amount, :refund_count,
+                  :refund_amount, :void_count, :decline_count, :error_count,
+                  :returned_item_amount, :returned_item_count, :chargeback_count,
+                  :chargeback_amount, :correction_notice_count, :charge_chageback_count,
+                  :charge_chargeback_amount, :refund_chargeback_amount,
+                  :refund_chargeback_count, :charge_returned_items_amount,
+                  :charge_returned_items_count, :refund_returned_items_amount,
+                  :refund_returned_items_count
+    
+  end
+
+end

data/lib/authorize_net/reporting/fds_filter.rb

@@ -0,0 +1,11 @@
+module AuthorizeNet::Reporting
+
+  # Models a fraud detection filter.
+  class FDSFilter
+    
+    include AuthorizeNet::Model
+    
+    attr_accessor :name, :action
+  end
+
+end

data/lib/authorize_net/reporting/response.rb

@@ -0,0 +1,127 @@
+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
+            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
+        
+        return transaction
+      end
+    end
+    
+  end
+end

data/lib/authorize_net/reporting/transaction.rb

@@ -0,0 +1,116 @@
+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 false.
+    # +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 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