xero_gateway 2.0.4 → 2.0.5

data/README.textile

@@ -147,7 +147,7 @@ h3. GET /api.xro/2.0/contacts (get_contacts)
 
 Gets all contact records for a particular Xero customer.
 <pre><code>    gateway.get_contacts(:type => :all, :sort => :name, :direction => :desc)
-    gateway.get_contacts(:type => :all, :updated_after => 1.month.ago) # modified since 1 month ago</code></pre>
+    gateway.get_contacts(:type => :all, :modified_since => 1.month.ago) # modified since 1 month ago</code></pre>
 
 
 
@@ -200,7 +200,7 @@ h3. GET /api.xro/2.0/invoices (get_invoices)
 
 Gets all invoice records for a particular Xero customer.
 <pre><code>    gateway.get_invoices
-    gateway.get_invoices(1.month.ago) # modified since 1 month ago</code></pre>
+    gateway.get_invoices(:modified_since => 1.month.ago) # modified since 1 month ago</code></pre>
 
 
 
@@ -214,8 +214,7 @@ Invoice and line item totals are calculated automatically.
       :due_date => 1.month.from_now,
       :invoice_number => "YOUR INVOICE NUMBER",
       :reference => "YOUR REFERENCE (NOT NECESSARILY UNIQUE!)",
-      :tax_inclusive => true,
-      :includes_tax => false
+      :line_amount_types => "Inclusive" # "Inclusive", "Exclusive" or "NoTax"
     })
     invoice.contact.name = "THE NAME OF THE CONTACT"
     invoice.contact.phone.number = "12345"
@@ -238,6 +237,59 @@ This method uses only a single API request to create/update multiple contacts.
 <pre><code>    invoices = [XeroGateway::Invoice.new(...), XeroGateway::Invoice.new(...)]
     result = gateway.create_invoices(invoices)</code></pre>
 
+h3. GET /api.xro/2.0/credit_note (get_credit_note_by_id)
+
+Gets an credit_note record for a specific Xero organisation
+<pre><code>    gateway.get_credit_note_by_id(credit_note_id)</code></pre>
+
+
+h3. GET /api.xro/2.0/credit_note (get_credit_note_by_number)
+
+Gets a credit note record for a specific Xero organisation
+<pre><code>    gateway.get_credit_note_by_number(credit_note_number)</code></pre>
+
+
+
+h3. GET /api.xro/2.0/credit_notes (get_credit_notes)
+
+Gets all credit note records for a particular Xero customer.
+<pre><code>    gateway.get_credit_notes
+    gateway.get_credit_notes(:modified_since => 1.month.ago) # modified since 1 month ago</code></pre>
+
+
+
+h3. PUT /api.xro/2.0/credit_note
+
+Inserts a credit note for a specific organization in Xero (Currently only adding new credit notes is allowed).
+
+CreditNote and line item totals are calculated automatically.
+<pre><code>    credit_note = gateway.build_credit_note({
+      :credit_note_type => "ACCRECCREDIT",
+      :credit_note_number => "YOUR CREDIT NOTE NUMBER",
+      :reference => "YOUR REFERENCE (NOT NECESSARILY UNIQUE!)",
+      :line_amount_types => "Inclusive" # "Inclusive", "Exclusive" or "NoTax"
+    })
+    credit_note.contact.name = "THE NAME OF THE CONTACT"
+    credit_note.contact.phone.number = "12345"
+    credit_note.contact.address.line_1 = "LINE 1 OF THE ADDRESS"    
+    credit_note.add_line_item({
+      :description => "THE DESCRIPTION OF THE LINE ITEM",
+      :unit_amount => 1000,
+      :tax_amount => 125,
+      :tracking_category => "THE TRACKING CATEGORY FOR THE LINE ITEM",
+      :tracking_option => "THE TRACKING OPTION FOR THE LINE ITEM"
+    })
+	
+		credit_note.create</code></pre>
+
+
+h3. PUT /api.xro/2.0/credit_notes
+
+Inserts multiple credit notes for a specific organization in Xero (currently only adding new credit notes is allowed).
+This method uses only a single API request to create/update multiple contacts.
+<pre><code>    credit_notes = [XeroGateway::CreditNote.new(...), XeroGateway::CreditNote.new(...)]
+    result = gateway.create_credit_notes(credit_notes)</code></pre>
+
 h3. GET /api.xro/2.0/accounts
 
 Gets all accounts for a specific organization in Xero.
@@ -286,4 +338,4 @@ You can specify a logger to use (so you can track down those tricky exceptions)
   gateway.logger = ActiveSupport::BufferedLogger.new("log_file_name.log")
 </pre>
 
-It doesn't have to be a buffered logger - anything that responds to "info" will do just fine.
+It doesn't have to be a buffered logger - anything that responds to "info" will do just fine.

data/lib/xero_gateway/account.rb

@@ -33,7 +33,7 @@ module XeroGateway
       'ZERORATED' =>        'Zero-rated supplies/sales from overseas (NZ Only)'
     } unless defined?(TAX_TYPE)
     
-    attr_accessor :code, :name, :type, :tax_type, :description
+    attr_accessor :account_id, :code, :name, :type, :tax_type, :description, :system_account, :enable_payments_to_account
     
     def initialize(params = {})
       params.each do |k,v|
@@ -42,7 +42,7 @@ module XeroGateway
     end
     
     def ==(other)
-      [:code, :name, :type, :tax_type, :description].each do |field|
+      [:account_id, :code, :name, :type, :tax_type, :description, :system_account, :enable_payments_to_account].each do |field|
         return false if send(field) != other.send(field)
       end
       return true
@@ -52,11 +52,14 @@ module XeroGateway
       b = Builder::XmlMarkup.new
       
       b.Account {
+        b.AccountID self.account_id
         b.Code self.code
         b.Name self.name
         b.Type self.type
         b.TaxType self.tax_type
         b.Description self.description
+        b.SystemAccount self.system_account unless self.system_account.nil?
+        b.EnablePaymentsToAccount self.enable_payments_to_account
       }
     end
     
@@ -64,11 +67,14 @@ module XeroGateway
       account = Account.new
       account_element.children.each do |element|
         case(element.name)
+          when "AccountID" then account.account_id = element.text
           when "Code" then account.code = element.text
           when "Name" then account.name = element.text
           when "Type" then account.type = element.text
           when "TaxType" then account.tax_type = element.text
           when "Description" then account.description = element.text
+          when "SystemAccount" then account.system_account = element.text
+          when "EnablePaymentsToAccount" then account.enable_payments_to_account = (element.text == 'true')
         end
       end      
       account

data/lib/xero_gateway/credit_note.rb

@@ -0,0 +1,275 @@
+module XeroGateway
+  class CreditNote
+    include Dates
+    include Money
+    
+    class Error < RuntimeError; end
+    class NoGatewayError < Error; end
+    class InvalidLineItemError < Error; end
+    
+    CREDIT_NOTE_TYPE = {
+      'ACCRECCREDIT' =>           'Accounts Receivable',
+      'ACCPAYCREDIT' =>           'Accounts Payable'
+    } unless defined?(CREDIT_NOTE_TYPE)
+    
+    LINE_AMOUNT_TYPES = {
+      "Inclusive" =>        'CreditNote lines are inclusive tax',
+      "Exclusive" =>        'CreditNote lines are exclusive of tax (default)',
+      "NoTax"     =>        'CreditNotes lines have no tax'
+    } unless defined?(LINE_AMOUNT_TYPES)
+    
+    CREDIT_NOTE_STATUS = {
+      'AUTHORISED' =>       'Approved credit_notes awaiting payment',
+      'DELETED' =>          'Draft credit_notes that are deleted',
+      'DRAFT' =>            'CreditNotes saved as draft or entered via API',
+      'PAID' =>             'CreditNotes approved and fully paid',
+      'SUBMITTED' =>        'CreditNotes entered by an employee awaiting approval',
+      'VOID' =>             'Approved credit_notes that are voided'
+    } unless defined?(CREDIT_NOTE_STATUS)
+    
+    GUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/ unless defined?(GUID_REGEX)
+        
+    # Xero::Gateway associated with this credit_note.
+    attr_accessor :gateway
+    
+    # Any errors that occurred when the #valid? method called.
+    attr_reader :errors
+
+    # Represents whether the line_items have been downloaded when getting from GET /API.XRO/2.0/CreditNotes
+    attr_accessor :line_items_downloaded
+  
+    # All accessible fields
+    attr_accessor :credit_note_id, :credit_note_number, :type, :status, :date, :reference, :line_amount_types, :currency_code, :line_items, :contact, :payments, :fully_paid_on, :amount_credited
+
+    
+    def initialize(params = {})
+      @errors ||= []
+      @payments ||= []
+      
+      # Check if the line items have been downloaded.
+      @line_items_downloaded = (params.delete(:line_items_downloaded) == true)
+      
+      params = {
+        :line_amount_types => "Inclusive"
+      }.merge(params)
+      
+      params.each do |k,v|
+        self.send("#{k}=", v)
+      end
+      
+      @line_items ||= []
+    end
+    
+    # Validate the Address record according to what will be valid by the gateway.
+    #
+    # Usage: 
+    #  address.valid?     # Returns true/false
+    #  
+    #  Additionally sets address.errors array to an array of field/error.
+    def valid?
+      @errors = []
+      
+      if !credit_note_id.nil? && credit_note_id !~ GUID_REGEX
+        @errors << ['credit_note_id', 'must be blank or a valid Xero GUID']
+      end
+            
+      if status && !CREDIT_NOTE_STATUS[status]
+        @errors << ['status', "must be one of #{CREDIT_NOTE_STATUS.keys.join('/')}"]
+      end
+
+      if line_amount_types && !LINE_AMOUNT_TYPES[line_amount_types]
+        @errors << ['line_amount_types', "must be one of #{LINE_AMOUNT_TYPES.keys.join('/')}"]
+      end
+      
+      unless date
+        @errors << ['credit_note_date', "can't be blank"]
+      end
+      
+      # Make sure contact is valid.
+      unless @contact && @contact.valid?
+        @errors << ['contact', 'is invalid']
+      end
+      
+      # Make sure all line_items are valid.
+      unless line_items.all? { | line_item | line_item.valid? }
+        @errors << ['line_items', "at least one line item invalid"]
+      end
+      
+      @errors.size == 0
+    end
+    
+    # Helper method to create the associated contact object.
+    def build_contact(params = {})
+      self.contact = gateway ? gateway.build_contact(params) : Contact.new(params)
+    end
+    
+    def contact
+      @contact ||= build_contact
+    end
+    
+    # Helper method to create a new associated line_item.
+    # Usage:
+    #   credit_note.add_line_item({:description => "Bob's Widgets", :quantity => 1, :unit_amount => 120})
+    def add_line_item(params = {})
+      line_item = nil
+      case params
+        when Hash then      line_item = LineItem.new(params)
+        when LineItem then  line_item = params
+        else                raise InvalidLineItemError
+      end
+      
+      @line_items << line_item
+      
+      line_item
+    end
+    
+    # Deprecated (but API for setter remains).
+    #
+    # As sub_total must equal SUM(line_item.line_amount) for the API call to pass, this is now
+    # automatically calculated in the sub_total method.
+    def sub_total=(value)
+    end
+    
+    # Calculate the sub_total as the SUM(line_item.line_amount).
+    def sub_total
+      line_items.inject(BigDecimal.new('0')) { | sum, line_item | sum + BigDecimal.new(line_item.line_amount.to_s) }
+    end
+    
+    # Deprecated (but API for setter remains).
+    #
+    # As total_tax must equal SUM(line_item.tax_amount) for the API call to pass, this is now
+    # automatically calculated in the total_tax method.
+    def total_tax=(value)
+    end
+    
+    # Calculate the total_tax as the SUM(line_item.tax_amount).
+    def total_tax
+      line_items.inject(BigDecimal.new('0')) { | sum, line_item | sum + BigDecimal.new(line_item.tax_amount.to_s) }
+    end
+    
+    # Deprecated (but API for setter remains).
+    #
+    # As total must equal sub_total + total_tax for the API call to pass, this is now
+    # automatically calculated in the total method.
+    def total=(value)
+    end
+    
+    # Calculate the toal as sub_total + total_tax.
+    def total
+      sub_total + total_tax
+    end
+    
+    # Helper method to check if the credit_note is accounts payable.
+    def accounts_payable?
+      type == 'ACCPAYCREDIT'
+    end
+    
+    # Helper method to check if the credit_note is accounts receivable.
+    def accounts_receivable?
+      type == 'ACCRECCREDIT'
+    end
+    
+    # Whether or not the line_items have been downloaded (GET/credit_notes does not download line items).
+    def line_items_downloaded?
+      @line_items_downloaded
+    end
+    
+    # If line items are not downloaded, then attempt a download now (if this record was found to begin with).
+    def line_items
+      if line_items_downloaded?
+        @line_items
+        
+      # There is an credit_note_is so we can assume this record was loaded from Xero.
+      # attempt to download the line_item records.
+      elsif credit_note_id =~ GUID_REGEX
+        raise NoGatewayError unless @gateway
+        
+        response = @gateway.get_credit_note(credit_note_id)
+        raise CreditNoteNotFoundError, "CreditNote with ID #{credit_note_id} not found in Xero." unless response.success? && response.credit_note.is_a?(XeroGateway::CreditNote)
+        
+        @line_items = response.credit_note.line_items
+        @line_items_downloaded = true
+        
+        @line_items
+        
+      # Otherwise, this is a new credit_note, so return the line_items reference.
+      else
+        @line_items
+      end
+    end
+    
+    def ==(other)
+      ["credit_note_number", "type", "status", "reference", "currency_code", "line_amount_types", "contact", "line_items"].each do |field|
+        return false if send(field) != other.send(field)
+      end
+      
+      ["date"].each do |field|
+        return false if send(field).to_s != other.send(field).to_s
+      end
+      return true
+    end
+    
+    # General purpose createsave method.
+    # If contact_id and contact_number are nil then create, otherwise, attempt to save.
+    def save
+      create
+    end
+    
+    # Creates this credit_note record (using gateway.create_credit_note) with the associated gateway.
+    # If no gateway set, raise a Xero::CreditNote::NoGatewayError exception.
+    def create
+      raise NoGatewayError unless gateway
+      gateway.create_credit_note(self)
+    end
+    
+    # Alias create as save as this is currently the only write action.
+    alias_method :save, :create
+            
+    def to_xml(b = Builder::XmlMarkup.new)
+      b.CreditNote {
+        b.Type self.type
+        contact.to_xml(b)
+        b.Date CreditNote.format_date(self.date || Date.today)
+        b.Status self.status if self.status
+        b.CreditNoteNumber self.credit_note_number if credit_note_number
+        b.Reference self.reference if self.reference
+        b.CurrencyCode self.currency_code if self.currency_code
+        b.LineAmountTypes self.line_amount_types
+        b.LineItems {
+          self.line_items.each do |line_item|
+            line_item.to_xml(b)
+          end
+        }
+      }
+    end
+    
+    #TODO UpdatedDateUTC
+    def self.from_xml(credit_note_element, gateway = nil, options = {})
+      credit_note = CreditNote.new(options.merge({:gateway => gateway}))
+      credit_note_element.children.each do |element|
+        case(element.name)
+          when "CreditNoteID" then credit_note.credit_note_id = element.text
+          when "CreditNoteNumber" then credit_note.credit_note_number = element.text            
+          when "Type" then credit_note.type = element.text
+          when "CurrencyCode" then credit_note.currency_code = element.text
+          when "Contact" then credit_note.contact = Contact.from_xml(element)
+          when "Date" then credit_note.date = parse_date(element.text)
+          when "Status" then credit_note.status = element.text
+          when "Reference" then credit_note.reference = element.text
+          when "LineAmountTypes" then credit_note.line_amount_types = element.text
+          when "LineItems" then element.children.each {|line_item| credit_note.line_items_downloaded = true; credit_note.line_items << LineItem.from_xml(line_item) }
+          when "SubTotal" then credit_note.sub_total = BigDecimal.new(element.text)
+          when "TotalTax" then credit_note.total_tax = BigDecimal.new(element.text)
+          when "Total" then credit_note.total = BigDecimal.new(element.text)
+          when "CreditNoteID" then credit_note.credit_note_id = element.text
+          when "CreditNoteNumber" then credit_note.credit_note_number = element.text            
+          when "Payments" then element.children.each { | payment | credit_note.payments << Payment.from_xml(payment) }
+          when "AmountDue" then credit_note.amount_due = BigDecimal.new(element.text)
+          when "AmountPaid" then credit_note.amount_paid = BigDecimal.new(element.text)
+          when "AmountCredited" then credit_note.amount_credited = BigDecimal.new(element.text)
+        end
+      end      
+      credit_note
+    end    
+  end
+end

data/lib/xero_gateway/exceptions.rb

@@ -38,4 +38,6 @@ module XeroGateway
   end
   
   class InvoiceNotFoundError < StandardError; end
-end
+
+  class CreditNoteNotFoundError < StandardError; end
+end

data/lib/xero_gateway/gateway.rb

@@ -21,16 +21,21 @@ module XeroGateway
     # Retrieve all contacts from Xero
     #
     # Usage : get_contacts(:order => :name)
-    #         get_contacts(:updated_after => Time)
+    #         get_contacts(:modified_since => Time)
     #
     # Note  : modified_since is in UTC format (i.e. Brisbane is UTC+10)
     def get_contacts(options = {})
       request_params = {}
 
+      if !options[:updated_after].nil?
+        warn '[warning] :updated_after is depracated in XeroGateway#get_contacts.  Use :modified_since'
+        options[:modified_since] = options.delete(:updated_after)
+      end
+
       request_params[:ContactID]     = options[:contact_id] if options[:contact_id]
       request_params[:ContactNumber] = options[:contact_number] if options[:contact_number]
       request_params[:OrderBy]       = options[:order] if options[:order]      
-      request_params[:ModifiedAfter] = Gateway.format_date_time(options[:updated_after]) if options[:updated_after]
+      request_params[:ModifiedAfter] = options[:modified_since] if options[:modified_since]
       request_params[:where]         = options[:where] if options[:where]
     
       response_xml = http_get(@client, "#{@xero_url}/Contacts", request_params)
@@ -134,7 +139,7 @@ module XeroGateway
       request_params[:InvoiceID]     = options[:invoice_id] if options[:invoice_id]
       request_params[:InvoiceNumber] = options[:invoice_number] if options[:invoice_number]
       request_params[:OrderBy]       = options[:order] if options[:order]      
-      request_params[:ModifiedAfter] = options[:modified_since]
+      request_params[:ModifiedAfter] = options[:modified_since] if options[:modified_since]
 
       request_params[:where]         = options[:where] if options[:where]
 
@@ -231,6 +236,116 @@ module XeroGateway
       response
     end
 
+    # Retrieves all credit_notes from Xero
+    #
+    # Usage : get_credit_notes
+    #         get_credit_notes(:credit_note_id => " 297c2dc5-cc47-4afd-8ec8-74990b8761e9")
+    #
+    # Note  : modified_since is in UTC format (i.e. Brisbane is UTC+10)
+    def get_credit_notes(options = {})
+      
+      request_params = {}
+      
+      request_params[:CreditNoteID]     = options[:credit_note_id] if options[:credit_note_id]
+      request_params[:CreditNoteNumber] = options[:credit_note_number] if options[:credit_note_number]
+      request_params[:OrderBy]       = options[:order] if options[:order]      
+      request_params[:ModifiedAfter] = options[:modified_since] if options[:modified_since]
+
+      request_params[:where]         = options[:where] if options[:where]
+
+      response_xml = http_get(@client, "#{@xero_url}/CreditNotes", request_params)
+
+      parse_response(response_xml, {:request_params => request_params}, {:request_signature => 'GET/CreditNotes'})
+    end
+    
+    # Retrieves a single credit_note
+    #
+    # Usage : get_credit_note("297c2dc5-cc47-4afd-8ec8-74990b8761e9") # By ID
+    #         get_credit_note("OIT-12345") # By number
+    def get_credit_note(credit_note_id_or_number)
+      request_params = {}
+      
+      url  = "#{@xero_url}/CreditNotes/#{URI.escape(credit_note_id_or_number)}"
+       
+      response_xml = http_get(@client, url, request_params)
+
+      parse_response(response_xml, {:request_params => request_params}, {:request_signature => 'GET/CreditNote'})
+    end
+    
+    # Factory method for building new CreditNote objects associated with this gateway.
+    def build_credit_note(credit_note = {})
+      case credit_note
+        when CreditNote then     credit_note.gateway = self
+        when Hash then        credit_note = CreditNote.new(credit_note.merge(:gateway => self))
+      end
+      credit_note
+    end
+  
+    # Creates an credit_note in Xero based on an credit_note object.
+    #
+    # CreditNote and line item totals are calculated automatically.
+    #
+    # Usage : 
+    #
+    #    credit_note = XeroGateway::CreditNote.new({
+    #      :credit_note_type => "ACCREC",
+    #      :due_date => 1.month.from_now,
+    #      :credit_note_number => "YOUR CREDIT_NOTE NUMBER",
+    #      :reference => "YOUR REFERENCE (NOT NECESSARILY UNIQUE!)",
+    #      :line_amount_types => "Inclusive"
+    #    })
+    #    credit_note.contact = XeroGateway::Contact.new(:name => "THE NAME OF THE CONTACT")
+    #    credit_note.contact.phone.number = "12345"
+    #    credit_note.contact.address.line_1 = "LINE 1 OF THE ADDRESS"    
+    #    credit_note.line_items << XeroGateway::LineItem.new(
+    #      :description => "THE DESCRIPTION OF THE LINE ITEM",
+    #      :unit_amount => 100,
+    #      :tax_amount => 12.5,
+    #      :tracking_category => "THE TRACKING CATEGORY FOR THE LINE ITEM",
+    #      :tracking_option => "THE TRACKING OPTION FOR THE LINE ITEM"
+    #    )
+    #
+    #    create_credit_note(credit_note)
+    def create_credit_note(credit_note)
+      request_xml = credit_note.to_xml
+      response_xml = http_put(@client, "#{@xero_url}/CreditNotes", request_xml)
+      response = parse_response(response_xml, {:request_xml => request_xml}, {:request_signature => 'PUT/credit_note'})
+      
+      # Xero returns credit_notes inside an <CreditNotes> tag, even though there's only ever
+      # one for this request
+      response.response_item = response.credit_notes.first
+      
+      if response.success? && response.credit_note && response.credit_note.credit_note_id
+        credit_note.credit_note_id = response.credit_note.credit_note_id 
+      end
+      
+      response
+    end
+    
+    #
+    # Creates an array of credit_notes with a single API request.
+    # 
+    # Usage :
+    #  credit_notes = [XeroGateway::CreditNote.new(...), XeroGateway::CreditNote.new(...)]
+    #  result = gateway.create_credit_notes(credit_notes)
+    #
+    def create_credit_notes(credit_notes)
+      b = Builder::XmlMarkup.new
+      request_xml = b.CreditNotes {
+        credit_notes.each do | credit_note |
+          credit_note.to_xml(b)
+        end
+      }
+      
+      response_xml = http_put(@client, "#{@xero_url}/CreditNotes", request_xml, {})
+
+      response = parse_response(response_xml, {:request_xml => request_xml}, {:request_signature => 'PUT/credit_notes'})
+      response.credit_notes.each_with_index do | response_credit_note, index |
+        credit_notes[index].credit_note_id = response_credit_note.credit_note_id if response_credit_note && response_credit_note.credit_note_id
+      end
+      response
+    end
+
     #
     # Gets all accounts for a specific organization in Xero.
     #
@@ -331,6 +446,7 @@ module XeroGateway
           when "Invoice" then response.response_item = Invoice.from_xml(element, self, {:line_items_downloaded => options[:request_signature] != "GET/Invoices"})
           when "Contacts" then element.children.each {|child| response.response_item << Contact.from_xml(child, self) }
           when "Invoices" then element.children.each {|child| response.response_item << Invoice.from_xml(child, self, {:line_items_downloaded => options[:request_signature] != "GET/Invoices"}) }
+          when "CreditNotes" then element.children.each {|child| response.response_item << CreditNote.from_xml(child, self, {:line_items_downloaded => options[:request_signature] != "GET/CreditNotes"}) }
           when "Accounts" then element.children.each {|child| response.response_item << Account.from_xml(child) }
           when "TaxRates" then element.children.each {|child| response.response_item << TaxRate.from_xml(child) }
           when "Currencies" then element.children.each {|child| response.response_item << Currency.from_xml(child) }

data/lib/xero_gateway/http.rb

@@ -85,10 +85,14 @@ module XeroGateway
         description   = error_details["oauth_problem_advice"].first
       
         # see http://oauth.pbworks.com/ProblemReporting
-        # Xero only appears to return either token_expired or token_rejected
+        # In addition to token_expired and token_rejected, Xero also returns
+        # 'rate limit exceeded' when more than 60 requests have been made in
+        # a second.
         case (error_details["oauth_problem"].first)
           when "token_expired"        then raise OAuth::TokenExpired.new(description)
           when "token_rejected"       then raise OAuth::TokenInvalid.new(description)
+          when "rate limit exceeded"  then raise OAuth::RateLimitExceeded.new(description)
+          else raise OAuth::UnknownError.new(error_details["oauth_problem"].first + ':' + description)
         end
       end
       
@@ -117,12 +121,12 @@ module XeroGateway
       end
       
       def handle_object_not_found!(response, request_url)
-        if request_url =~ /Invoices/
-          raise InvoiceNotFoundError.new("Invoice not found in Xero.")
-        else
-          raise ObjectNotFound.new(request_url)
+        case(request_url)
+          when /Invoices/ then raise InvoiceNotFoundError.new("Invoice not found in Xero.")
+          when /CreditNotes/ then raise CreditNoteNotFoundError.new("Credit Note not found in Xero.")
+          else raise ObjectNotFound.new(request_url)
         end
       end
       
   end
-end
+end

data/lib/xero_gateway/oauth.rb

@@ -10,6 +10,8 @@ module XeroGateway
     
     class TokenExpired < StandardError; end
     class TokenInvalid < StandardError; end
+    class RateLimitExceeded < StandardError; end
+    class UnknownError < StandardError; end
         
     unless defined? XERO_CONSUMER_OPTIONS
       XERO_CONSUMER_OPTIONS = {
@@ -53,4 +55,4 @@ module XeroGateway
     end
     
   end
-end
+end

data/lib/xero_gateway/response.rb

@@ -7,9 +7,11 @@ module XeroGateway
     end
     
     alias_method :invoice,      :response_item
+    alias_method :credit_note,  :response_item
     alias_method :contact,      :response_item
     alias_method :organisation, :response_item
     alias_method :invoices,     :array_wrapped_response_item
+    alias_method :credit_notes, :array_wrapped_response_item
     alias_method :contacts,     :array_wrapped_response_item
     alias_method :accounts,     :array_wrapped_response_item
     alias_method :tracking_categories, :array_wrapped_response_item