authorizenet_blaq 1.9.3

data/lib/authorize_net/key_value_response.rb

@@ -0,0 +1,117 @@
+module AuthorizeNet
+  
+  # The core, key/value response class. You shouldn't instantiate this one.
+  # Instead you should use AuthorizeNet::AIM::Response or AuthorizeNet::SIM::Response.
+  class KeyValueResponse < AuthorizeNet::Response
+    
+    # Defines constants for each response code.
+    module ResponseCode
+      APPROVED = '1'
+      DECLINED = '2'
+      ERROR = '3'
+      HELD = '4'
+    end
+    
+    # Defines constants for each address verification response code.
+    module AVSResponseCode
+      ADDRESS_MATCH_NOT_ZIP = 'A'
+      NO_INFO = 'B'
+      ERROR = 'E'
+      NON_US = 'G'
+      NO_MATCH = 'N'
+      NOT_APPLICABLE = 'P'
+      RETRY = 'R'
+      NOT_SUPPOPRTED = 'S'
+      UNAVAILABLE = 'U'
+      ZIP9_MATCH_NOT_ADDRESS = 'W'
+      ADDRESS_AND_ZIP9_MATCH = 'X'
+      ADDRESS_AND_ZIP5_MATCH = 'Y'
+      ZIP5_MATCH_NOT_ADDRESS = 'Z'
+    end
+    
+    # Defines constants for each supported credit card type.
+    module CardType
+      VISA = 'Visa'
+      MASTER_CARD = 'MasterCard'
+      AMEX = 'American Express'
+      DISCOVER = 'Discover'
+      DINERS_CLUB = 'Diners Club'
+      JCB = 'JCB'
+    end
+    
+    # Defines constants for CCV code validation responses.
+    module CCVResponseCode
+      MATCH = 'M'
+      NO_MATCH = 'N'
+      NOT_PROCESSED = 'P'
+      SHOULD_HAVE_BEEN_PRESENT = 'S'
+      UNABLE_TO_PROCESS = 'U'
+    end
+    
+    # Defines constants for CAVV code validation responses.
+    module CAVVResponseCode
+      ERRONEOUS_DATA = '0'
+      FAILED_VALIDATION = '1'
+      PASSED_VALIDATION = '2'
+      ISSUER_ATTEMPT_INCOMPLETE = '3'
+      ISSUER_SYSTEM_ERROR = '4'
+      FAILED_ISSUER_AVAILABLE = '7'
+      PASSED_ISSUER_AVAILABLE = '8'
+      FAILED_ISSUER_UNAVAILABLE = '9'
+      PASSED_ISSUER_UNAVAILABLE = 'A'
+      PASSED_NO_LIABILITY_SHIFT = 'B'
+    end
+    
+    # Check to see if the transaction was approved.
+    def approved?
+      @fields[:response_code] == ResponseCode::APPROVED
+    end
+    
+    # Check to see if the transaction was declined.
+    def declined?
+      @fields[:response_code] == ResponseCode::DECLINED
+    end
+    
+    # Check to see if the transaction was returned with an error.
+    def error?
+      @fields[:response_code] == ResponseCode::ERROR
+    end
+    
+    # Check to see if the transaction was held for review by Authorize.Net.
+    def held?
+      @fields[:response_code] == ResponseCode::HELD
+    end
+    
+    # Returns the response code received from the gateway. Note: its better to use
+    # success?, approved?, etc. to check the response code.
+    def response_code
+      @fields[:response_code]
+    end
+    
+    # Returns the response reason code received from the gateway. This code can be used
+    # to identify why something failed by referencing the AIM documentation.
+    def response_reason_code
+      @fields[:response_reason_code]
+    end
+    
+    # Returns the response reason text received from the gateway. This is a brief, human readable
+    # explanation of why you got the response code that you got. Note that these strings tend to be
+    # a bit vague. More detail can be gleaned from the response_reason_code.
+    def response_reason_text
+      @fields[:response_reason_text]
+    end
+    
+    # Returns all the fields returned in the response, keyed by their API name. Custom fields are NOT
+    # included (see custom_fields).
+    def fields
+      @fields
+    end
+    
+    # Returns all the custom fields returned in the response, keyed by their field name.
+    def custom_fields
+      @custom_fields
+    end
+    
+  end
+  
+end

data/lib/authorize_net/key_value_transaction.rb

@@ -0,0 +1,291 @@
+module AuthorizeNet
+  
+  # The core, key/value transaction class. You shouldn't instantiate this one.
+  # Instead you should use AuthorizeNet::AIM::Transaction or AuthorizeNet::SIM::Transaction.
+  class KeyValueTransaction < AuthorizeNet::Transaction
+    
+    # Constants for both the various Authorize.Net payment gateways are defined here.
+    module Gateway
+      LIVE = 'https://secure2.authorize.net/gateway/transact.dll'
+      TEST = 'https://test.authorize.net/gateway/transact.dll'
+      CARD_PRESENT_LIVE = 'https://cardpresent.authorize.net/gateway/transact.dll'
+      CARD_PRESENT_TEST = 'https://test.authorize.net/gateway/transact.dll'
+    end
+    
+    # Constants for both the various Authorize.Net payment transaction types are defined here.
+    module Type
+      AUTHORIZE_AND_CAPTURE = "AUTH_CAPTURE"
+      AUTHORIZE_ONLY = "AUTH_ONLY"
+      CAPTURE_ONLY = "CAPTURE_ONLY"
+      CREDIT = "CREDIT"
+      PRIOR_AUTHORIZATION_AND_CAPTURE = "PRIOR_AUTH_CAPTURE"
+      VOID = "VOID"
+    end
+    
+    # Constants for the various device types used in card present transactions.
+    module DeviceType
+      UNKNOWN = 1
+      UNATTENDED = 2
+      SELF_SERVICE = 3
+      CASH_REGISTER = 4
+      PC_TERMINAL = 5
+      AIRPAY = 6
+      WIRELESS_POS = 7
+      WEBSITE_TERMINAL = 8
+      DIAL_TERMINAL = 9
+      VIRTUAL_TERMINAL = 10
+    end
+    
+    # Constants for the various market types used in card present transactions.
+    module MarketType
+      RETAIL = 2
+    end
+    
+    # The default options for purchase.
+    @@purchase_option_defaults = {
+      :cardholder_auth_value => nil,
+      :cardholder_auth_indicator => nil
+    }
+    
+    # The default options for authorize.
+    @@authorize_option_defaults = {
+      :cardholder_auth_value => nil,
+      :cardholder_auth_indicator => nil
+    }
+    
+    # Fields to convert to/from booleans.
+    @@boolean_fields = []
+    
+    # Fields to convert to/from BigDecimal.
+    @@decimal_fields = []
+    
+    # DO NOT USE. Instantiate AuthorizeNet::AIM::Transaction or AuthorizeNet::SIM::Transaction instead.
+    def initialize()
+      super
+      @custom_fields ||= {}
+      @test_mode ||= false
+      @version = '3.1'
+    end
+    
+    # Checks if the transaction has been configured for test mode or not. Return TRUE if the
+    # transaction is a test transaction, FALSE otherwise. All transactions run against the sandbox
+    # are considered test transactions.
+    def test?
+      !!@test_mode
+    end
+    
+    # Returns the current API version that we are adhering to
+    def version
+      @version
+    end
+        
+    # Sets arbitrary custom fields, overwriting existing values if they exist. Takes a hash of key/value pairs, 
+    # where the keys are the field names. You can set a field to Nil to unset it.
+    def set_custom_fields(fields = {})
+      @custom_fields.merge!(fields)
+    end
+    
+    # Returns the current hash of custom fields.
+    def custom_fields
+      @custom_fields
+    end
+    
+    # Convenience method for adding line items to a transaction.
+    def add_line_item(id = nil, name = nil, description = nil, quantity = nil, price = nil, taxable = nil)
+      line_item = "#{id}<|>#{name}<|>#{description}<|>#{quantity}<|>#{price}<|>#{taxable}"
+      if @fields.has_key?(:line_item)
+        @fields[:line_item] = @fields[:line_item].to_a << line_item
+      else
+        @fields[:line_item] = [line_item]
+      end
+    end
+    
+    # Takes an instance of AuthorizeNet::EmailReceipt and adds it to the transaction.
+    def set_email_receipt(email)
+      @fields.merge!(email.to_hash)
+    end
+    
+    # Returns the type of transaction.
+    def type
+      @type
+    end
+    
+    # Sets the type of transaction.
+    def type=(type)
+      case type
+      when :authorize, :auth_only
+        @type = Type::AUTHORIZE_ONLY
+      when :purchase, :auth_and_capture
+        @type = Type::AUTHORIZE_AND_CAPTURE
+      when :refund, :credit
+        @type = Type::CREDIT
+      when :void
+        @type = Type::VOID
+      when :capture, :capture_only
+        @type = Type::CAPTURE_ONLY
+      when :prior_auth_capture
+        @type = Type::PRIOR_AUTHORIZATION_AND_CAPTURE
+      else
+        @type = type
+      end
+    end
+    
+    # Sets up and submits a standard purchase (AUTHORIZE_AND_CAPTURE) transaction. Returns a response object. If the transaction
+    # has already been run, it will return nil.
+    # 
+    # +amount+:: The amount to charge. Accepts a string in the format "%0.2f", a Float or a BigDecimal.
+    # +credit_card+:: The credit card or eCheck to charge. Accepts an instance of AuthorizeNet::CreditCard, AuthorizeNet::ECheck, or a string of digits (in which case the expiration should be added using set_fields).
+    # +options+:: A hash with any of following keys: cardholder_auth_indicator, cardholder_auth_value. These are for CAVV and can be ignored in most cases.
+    # 
+    # 
+    # Typical usage:
+    # 
+    #   credit_card = AuthorizeNet::CreditCard.new('4111111111111111', '1120')
+    #   response = transaction.purchase(10.0, credit_card)
+    # 
+    def purchase(amount, credit_card, options = {})
+      handle_payment_argument(credit_card)
+      options = @@purchase_option_defaults.merge(options)
+      handle_cavv_options(options)
+      set_fields(:amount => amount)
+      self.type = Type::AUTHORIZE_AND_CAPTURE
+      run
+    end
+    
+    # Sets up and submits a refund (CREDIT) transaction. Returns a response object. If the transaction
+    # has already been run, it will return nil.
+    # 
+    # +amount+:: The amount to refund. Accepts a string in the format "%0.2f", a Float or a BigDecimal.
+    # +transaction+:: The transaction ID to apply the refund to. Accepts a string of the transaction ID, an instance of AuthorizeNet::Transaction or AuthorizeNet::Response.
+    # +credit_card+:: The credit card or eCheck to charge. Accepts an instance of AuthorizeNet::CreditCard, AuthorizeNet::ECheck, or a string of digits. In many cases you only need the last 4 digits of the credit card here.
+    # 
+    # 
+    # Typical usage:
+    # 
+    #   response = transaction.refund(10.0, '123456789', '1212')
+    #
+    def refund(amount, transaction, credit_card)
+      handle_payment_argument(credit_card)
+      handle_transaction_argument(transaction)
+      set_fields(:amount => amount)
+      self.type = Type::CREDIT
+      run
+    end
+    
+    # Sets up and submits a refund (CREDIT) transaction for a transaction that was not originally
+    # submitted via the payment gateway. Note that this is a special feature which requires your
+    # account to support ECC (expanded credits capability) transactions.
+    # 
+    # +amount+:: The amount to refund. Accepts a string in the format "%0.2f", a Float or a BigDecimal.
+    # +credit_card+:: The credit card or eCheck to charge. Accepts an instance of AuthorizeNet::CreditCard, AuthorizeNet::ECheck, or a string of digits.
+    # 
+    # Typical usage:
+    # 
+    #   response = transaction.unlinked_credit(10.0, '4111111111111111')
+    # 
+    def unlinked_credit(amount, credit_card)
+      handle_payment_argument(credit_card)
+      set_fields(:amount => amount)
+      self.type = Type::CREDIT
+      run
+    end
+    
+    # Sets up and submits a void (VOID) transaction. Returns a response object. If the transaction
+    # has already been run, it will return nil. Note that you can only void unsettled transactions.
+    # 
+    # +transaction+:: The transaction ID of the transaction to void. Accepts a string of the transaction ID, an instance of AuthorizeNet::Transaction or AuthorizeNet::Response.
+    # 
+    # 
+    # Typical usage:
+    # 
+    #   response = transaction.void('123456789')
+    #
+    def void(transaction)
+      handle_transaction_argument(transaction)
+      self.type = Type::VOID
+      run
+    end
+    
+    # Sets up and submits an authorize (AUTH_ONLY) transaction. Returns a response object. If the transaction
+    # has already been run, it will return nil. Use this to put a hold on funds, but don't actually charge
+    # the card yet.
+    # 
+    # +amount+:: The amount to authorize. Accepts a string in the format "%0.2f", a Float or a BigDecimal.
+    # +credit_card+:: The credit card or eCheck to charge. Accepts an instance of AuthorizeNet::CreditCard, AuthorizeNet::ECheck, or a string of digits (in which case the expiration should be added using set_fields).
+    # +options+:: A hash with any of following keys: cardholder_auth_indicator, cardholder_auth_value. These are for CAVV and can be ignored in most cases.
+    # 
+    # 
+    # Typical usage:
+    # 
+    #   credit_card = AuthorizeNet::CreditCard.new('4111111111111111', '1120')
+    #   response = transaction.authorize(10.0, credit_card)
+    #
+    def authorize(amount, credit_card, options = {})
+      handle_payment_argument(credit_card)
+      options = @@authorize_option_defaults.merge(options)
+      handle_cavv_options(options)
+      set_fields(:amount => amount)
+      self.type = Type::AUTHORIZE_ONLY
+      run
+    end
+    
+    # Sets up and submits a capture (CAPTURE_ONLY) transaction. Returns a response object. If the transaction
+    # has already been run, it will return nil. Note that you can not capture a transaction that was made
+    # though the AIM API using this method. Use prior_auth_capture instead.
+    # 
+    # +amount+:: The amount to capture. Accepts a string in the format "%0.2f", a Float or a BigDecimal.
+    # +authorization_code+:: The authorization code of the transaction to capture. Accepts a string.
+    # 
+    # 
+    # Typical usage:
+    # 
+    #   response = transaction.capture(10.0, '123FAKE')
+    #
+    def capture(amount, authorization_code)
+      set_fields(:amount => amount, :auth_code => authorization_code)
+      self.type = Type::CAPTURE_ONLY
+      run
+    end
+    
+    # Sets up and submits a capture (PRIOR_AUTH_CAPTURE) transaction. Returns a response object. Use this method
+    # to actually charge a card that you previously put a hold on (using authorize).
+    # 
+    # +transaction+:: The transaction ID to capture. Accepts a string of the transaction ID, an instance of AuthorizeNet::Transaction or AuthorizeNet::Response.
+    # +amount+:: The amount to capture (only if less than the amount originally authorized, otherwise leave as Nil). Accepts a string in the format "%0.2f", a Float, a BigDecimal or Nil.
+    # 
+    # 
+    # Typical usage:
+    # 
+    #   response = transaction.prior_auth_capture('123456789')
+    #
+    def prior_auth_capture(transaction, amount = nil)
+      handle_transaction_argument(transaction)
+      set_fields(:amount => amount)
+      self.type = Type::PRIOR_AUTHORIZATION_AND_CAPTURE
+      run
+    end
+    
+    #:enddoc:
+    protected
+    
+    # Internal method to handle multiple types of transaction arguments.
+    def handle_transaction_argument(transaction)
+      case transaction
+      when Transaction
+        set_fields(:trans_id => transaction.response.transaction_id)
+      when Response
+        set_fields(:trans_id => transaction.transaction_id)
+      else
+        set_fields(:trans_id => transaction)
+      end
+    end
+    
+    # Internal method to handle CAVV options.
+    def handle_cavv_options(options)
+      set_fields(:authentication_indicator => options[:cardholder_auth_indicator]) unless options[:cardholder_auth_indicator].nil?
+      set_fields(:cardholder_authentication_value => options[:cardholder_auth_value]) unless options[:cardholder_auth_value].nil?
+    end
+    
+  end
+  
+end

data/lib/authorize_net/line_item.rb

@@ -0,0 +1,25 @@
+module AuthorizeNet
+  
+  # Models an line item.
+  class LineItem
+    
+    include AuthorizeNet::Model
+    
+    attr_accessor :id, :name, :description, :quantity, :price, :taxable
+    
+    def to_hash
+      hash = {
+        :line_item_id => @id,
+        :line_item_name => @name,
+        :line_item_description => @description,
+        :line_item_quantity => @quantity,
+        :line_item_unit_price => @price,
+        :line_item_taxable => @taxable
+      }
+      hash.delete_if {|k, v| v.nil?}
+      hash
+    end
+    
+  end
+  
+end

data/lib/authorize_net/order.rb

@@ -0,0 +1,42 @@
+module AuthorizeNet
+  
+  # Models an order.
+  class Order
+    
+    include AuthorizeNet::Model
+    
+    attr_accessor :invoice_num, :description, :tax, :tax_name, :tax_description, :freight, :freight_name, :freight_description, :duty, :duty_name, :duty_description, :tax_exempt, :po_num, :line_items
+    
+    def add_line_item(id = nil, name = nil, description = nil, quantity = nil, price = nil, taxable = nil)
+      if id.kind_of?(AuthorizeNet::LineItem)
+        line_item = id
+      else
+        line_item = AuthorizeNet::LineItem.new({:id => id, :name => name, :description => description, :quantity => quantity, :price => price, :taxable => taxable})
+      end
+      @line_items = @line_items.to_a << line_item
+    end
+    
+    def to_hash
+      hash = {
+        :invoice_num => @invoice_num,
+        :description => @description,
+        :tax => @tax,
+        :tax_name => @tax_name,
+        :tax_description => @tax_description,
+        :freight => @freight,
+        :freight_name => @freight_name,
+        :freight_description => @freight_description,
+        :duty => @duty,
+        :duty_name => @duty_name,
+        :duty_description => @duty_description,
+        :tax_exempt => @tax_exempt,
+        :po_num => @po_num,
+        :line_items => handle_multivalue_hashing(@line_items)
+      }
+      hash.delete_if {|k, v| v.nil?}
+      hash
+    end
+    
+  end
+  
+end

data/lib/authorize_net/payment_methods/credit_card.rb

@@ -0,0 +1,62 @@
+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.new.tap do |ch|
+        ch[:method] = PAYMENT_METHOD_CODE
+        ch[:card_num] = @card_number
+        ch[:exp_date] = @expiration
+        ch[:card_code] = @card_code if @card_code
+        ch[:track1] = @track_1.match(/(%|^)(.*?)(\?|$)/)[2] if @track_1
+        ch[:track2] = @track_2.match(/(;|^)(.*?)(\?|$)/)[2] if @track_2
+        #ch[:track1] = @track_1.match(/^%(?<fc>.)(?<p>[\d]{1,19}+)\^(?<n>.{2,26})\^(?<e>[\d]{0,4}|\^)(?<sc>[\d]{0,3}|\^)(?<dd>.*)\?\Z/) if @track_1
+        #ch[:track2] = @track_2.match(/\A;(?<pan>[\d]{1,19}+)=(?<expiration>[\d]{0,4}|=)(?<service_code>[\d]{0,3}|=)(?<discretionary_data>.*)\?\Z/) if @track_2
+      end
+    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