xero_gateway 2.0.2

data/lib/xero_gateway/contact.rb

@@ -0,0 +1,206 @@
+module XeroGateway
+  class Contact
+    include Dates
+    
+    class Error < RuntimeError; end
+    class NoGatewayError < Error; end
+    
+    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)
+    
+    CONTACT_STATUS = {
+      'ACTIVE' =>     'Active',
+      'DELETED' =>    'Deleted'
+    } unless defined?(CONTACT_STATUS)
+            
+    # Xero::Gateway associated with this contact.
+    attr_accessor :gateway
+    
+    # Any errors that occurred when the #valid? method called.
+    attr_reader :errors
+    
+    attr_accessor :contact_id, :contact_number, :status, :name, :first_name, :last_name, :email, :addresses, :phones, :updated_at,
+                  :bank_account_details, :tax_number, :accounts_receivable_tax_type, :accounts_payable_tax_type, :is_customer, :is_supplier,
+                  :default_currency, :contact_groups
+
+        
+    def initialize(params = {})
+      @errors ||= []
+
+      params = {}.merge(params)      
+      params.each do |k,v|
+        self.send("#{k}=", v)
+      end
+
+      @phones ||= []
+      @addresses ||= []
+    end
+    
+    def address=(address)
+      self.addresses = [address]
+    end
+    
+    def address
+      self.addresses[0] ||= Address.new
+    end
+    
+    # Helper method to add a new address object to this contact.
+    #
+    # Usage:
+    #  contact.add_address({
+    #    :address_type =>   'STREET',
+    #    :line_1 =>         '100 Queen Street',
+    #    :city =>           'Brisbane',
+    #    :region =>         'QLD',
+    #    :post_code =>      '4000',
+    #    :country =>        'Australia'
+    #  })
+    def add_address(address_params)
+      self.addresses << Address.new(address_params)
+    end
+    
+    def phone=(phone)
+      self.phones = [phone]
+    end
+    
+    def phone
+      if @phones.size > 1
+        @phones.detect {|p| p.phone_type == 'DEFAULT'} || phones[0]
+      else
+        @phones[0] ||= Phone.new
+      end
+    end
+    
+    # Helper method to add a new phone object to this contact.
+    #
+    # Usage:
+    #  contact.add_phone({
+    #    :phone_type =>   'MOBILE',
+    #    :number =>       '0400123123'
+    #  })
+    def add_phone(phone_params = {})
+      self.phones << Phone.new(phone_params)
+    end
+    
+    # Validate the Contact record according to what will be valid by the gateway.
+    #
+    # Usage: 
+    #  contact.valid?     # Returns true/false
+    #  
+    #  Additionally sets contact.errors array to an array of field/error.
+    def valid?
+      @errors = []
+      
+      if !contact_id.nil? && contact_id !~ GUID_REGEX
+        @errors << ['contact_id', 'must be blank or a valid Xero GUID']
+      end
+      
+      if status && !CONTACT_STATUS[status]
+        @errors << ['status', "must be one of #{CONTACT_STATUS.keys.join('/')}"]
+      end
+      
+      unless name
+        @errors << ['name', "can't be blank"]
+      end
+      
+      # Make sure all addresses are correct.
+      unless addresses.all? { | address | address.valid? }
+        @errors << ['addresses', 'at least one address is invalid']
+      end
+      
+      # Make sure all phone numbers are correct.
+      unless phones.all? { | phone | phone.valid? }
+        @errors << ['phones', 'at leaset one phone is invalid']
+      end
+      
+      @errors.size == 0
+    end
+    
+    # General purpose create/save method.
+    # If contact_id and contact_number are nil then create, otherwise, attempt to save.
+    def save
+      if contact_id.nil? && contact_number.nil?
+        create
+      else
+        update
+      end
+    end
+    
+    # Creates this contact record (using gateway.create_contact) with the associated gateway.
+    # If no gateway set, raise a Xero::Contact::NoGatewayError exception.
+    def create
+      raise NoGatewayError unless gateway
+      gateway.create_contact(self)
+    end
+    
+    # Creates this contact record (using gateway.update_contact) with the associated gateway.
+    # If no gateway set, raise a Xero::Contact::NoGatewayError exception.
+    def update
+      raise NoGatewayError unless gateway
+      gateway.update_contact(self)
+    end
+        
+    def to_xml(b = Builder::XmlMarkup.new)
+      b.Contact {
+        b.ContactID self.contact_id if self.contact_id
+        b.ContactNumber self.contact_number if self.contact_number
+        b.Name self.name
+        b.EmailAddress self.email if self.email
+        b.FirstName self.first_name if self.first_name
+        b.LastName self.last_name if self.last_name
+        b.BankAccountDetails self.bank_account_details if self.bank_account_details
+        b.TaxNumber self.tax_number if self.tax_number
+        b.AccountsReceivableTaxType self.accounts_receivable_tax_type if self.accounts_receivable_tax_type
+        b.AccountsPayableTaxType self.accounts_payable_tax_type if self.accounts_payable_tax_type
+        b.ContactGroups if self.contact_groups
+        b.IsCustomer true if self.is_customer
+        b.IsSupplier true if self.is_supplier
+        b.DefaultCurrency if self.default_currency
+        b.Addresses {
+          addresses.each { |address| address.to_xml(b) }
+        }
+        b.Phones {
+          phones.each { |phone| phone.to_xml(b) }
+        }
+      }
+    end
+    
+    # Take a Contact element and convert it into an Contact object
+    def self.from_xml(contact_element, gateway = nil)
+      contact = Contact.new(:gateway => gateway)
+      contact_element.children.each do |element|
+        case(element.name)
+          when "ContactID" then contact.contact_id = element.text
+          when "ContactNumber" then contact.contact_number = element.text
+          when "ContactStatus" then contact.status = element.text
+          when "Name" then contact.name = element.text
+          when "FirstName" then contact.first_name = element.text
+          when "LastName" then contact.last_name = element.text
+          when "EmailAddress" then contact.email = element.text
+          when "Addresses" then element.children.each {|address_element| contact.addresses << Address.from_xml(address_element)}
+          when "Phones" then element.children.each {|phone_element| contact.phones << Phone.from_xml(phone_element)}
+          when "FirstName" then contact.first_name = element.text
+          when "LastName"  then contact.last_name  = element.text
+          when "BankAccountDetails" then contact.bank_account_details = element.text
+          when "TaxNumber" then contact.tax_number = element.text
+          when "AccountsReceivableTaxType" then contact.accounts_receivable_tax_type = element.text
+          when "AccountsPayableTaxType" then contact.accounts_payable_tax_type = element.text
+          when "ContactGroups" then contact.contact_groups = element.text
+          when "IsCustomer" then contact.is_customer = (element.text == "true")
+          when "IsSupplier" then contact.is_supplier = (element.text == "true")
+          when "DefaultCurrency" then contact.default_currency = element.text
+        end
+      end
+      contact
+    end
+    
+    def ==(other)
+      [ :contact_id, :contact_number, :status, :name, :first_name, :last_name, :email, :addresses, :phones, :updated_at,
+        :bank_account_details, :tax_number, :accounts_receivable_tax_type, :accounts_payable_tax_type, :is_customer, :is_supplier,
+        :default_currency, :contact_groups ].each do |field|
+        return false if send(field) != other.send(field)
+      end
+      return true
+    end    
+        
+  end
+end

data/lib/xero_gateway/currency.rb

@@ -0,0 +1,56 @@
+module XeroGateway
+  class Currency
+    
+    unless defined? ATTRS
+      ATTRS = {
+        "Code" 	       => :string,     # 3 letter alpha code for the currency – see list of currency codes
+        "Description"  => :string, 	   # Name of Currency
+      }
+    end
+    
+    attr_accessor *ATTRS.keys.map(&:underscore)
+    
+    def initialize(params = {})
+      params.each do |k,v|
+        self.send("#{k}=", v)
+      end
+    end
+    
+    def ==(other)
+      ATTRS.keys.map(&:underscore).each do |field|
+        return false if send(field) != other.send(field)
+      end
+      return true
+    end
+    
+    def to_xml
+      b = Builder::XmlMarkup.new
+      
+      b.Currency do
+        ATTRS.keys.each do |attr|
+          eval("b.#{attr} '#{self.send(attr.underscore.to_sym)}'")
+        end
+      end
+    end
+    
+    def self.from_xml(currency_element)
+      Currency.new.tap do |currency|
+        currency_element.children.each do |element|
+        
+          attribute             = element.name
+          underscored_attribute = element.name.underscore
+        
+          raise "Unknown attribute: #{attribute}" unless ATTRS.keys.include?(attribute)
+        
+          case (ATTRS[attribute])
+            when :boolean then  currency.send("#{underscored_attribute}=", (element.text == "true"))
+            when :float   then  currency.send("#{underscored_attribute}=", element.text.to_f)
+            else                currency.send("#{underscored_attribute}=", element.text)
+          end
+          
+        end
+      end
+    end
+    
+  end
+end

data/lib/xero_gateway/dates.rb

@@ -0,0 +1,25 @@
+module XeroGateway
+  module Dates
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+    
+    module ClassMethods
+      def format_date(time)
+        return time.strftime("%Y-%m-%d")
+      end
+      
+      def format_date_time(time)
+        return time.strftime("%Y%m%d%H%M%S")
+      end
+      
+      def parse_date(time)
+        Date.civil(time[0..3].to_i, time[5..6].to_i, time[8..9].to_i)
+      end
+      
+      def parse_date_time(time)
+        Time.local(time[0..3].to_i, time[5..6].to_i, time[8..9].to_i, time[11..12].to_i, time[14..15].to_i, time[17..18].to_i)
+      end
+    end
+  end
+end

data/lib/xero_gateway/error.rb

@@ -0,0 +1,18 @@
+module XeroGateway
+  class Error
+    attr_accessor :description, :date_time, :type, :message
+    
+    def initialize(params = {})
+      params.each do |k,v|
+        self.send("#{k}=", v)
+      end
+    end
+    
+    def ==(other)
+      [:description, :date_time, :type, :message].each do |field|
+        return false if send(field) != other.send(field)
+      end
+      return true
+    end
+  end
+end

data/lib/xero_gateway/exceptions.rb

@@ -0,0 +1,41 @@
+module XeroGateway
+  class ApiException < StandardError
+    
+    def initialize(type, message, xml)
+      @type     = type
+      @message  = message
+      @xml      = xml
+    end
+    
+    def message
+      "#{@type}: #{@message} \n Generated by the following XML: \n #{@xml}"
+    end
+    
+  end
+  
+  class UnparseableResponse < StandardError
+    
+    def initialize(root_element_name)
+      @root_element_name = root_element_name
+    end
+    
+    def message
+      "A root element of #{@root_element_name} was returned, and we don't understand that!"
+    end
+      
+  end
+  
+  class ObjectNotFound < StandardError
+    
+    def initialize(api_endpoint)
+      @api_endpoint = api_endpoint
+    end
+    
+    def message
+      "Couldn't find object for API Endpoint #{@api_endpoint}"
+    end
+    
+  end
+  
+  class InvoiceNotFoundError < StandardError; end
+end

data/lib/xero_gateway/gateway.rb

@@ -0,0 +1,363 @@
+module XeroGateway
+  
+  class Gateway
+    include Http
+    include Dates
+      
+    attr_accessor :client, :xero_url, :logger
+    
+    extend Forwardable
+    def_delegators :client, :request_token, :access_token, :authorize_from_request, :authorize_from_access
+
+    #
+    # The consumer key and secret here correspond to those provided
+    # to you by Xero inside the API Previewer. 
+    def initialize(consumer_key, consumer_secret, options = {})
+      @xero_url = options[:xero_url] || "https://api.xero.com/api.xro/2.0"
+      @client   = OAuth.new(consumer_key, consumer_secret, options)
+    end
+  
+    #
+    # Retrieve all contacts from Xero
+    #
+    # Usage : get_contacts(:order => :name)
+    #         get_contacts(:updated_after => Time)
+    #
+    # Note  : modified_since is in UTC format (i.e. Brisbane is UTC+10)
+    def get_contacts(options = {})
+      request_params = {}
+
+      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[:where]         = options[:where] if options[:where]
+    
+      response_xml = http_get(@client, "#{@xero_url}/Contacts", request_params)
+    
+      parse_response(response_xml, {:request_params => request_params}, {:request_signature => 'GET/contacts'})
+    end
+    
+    # Retrieve a contact from Xero
+    # Usage get_contact_by_id(contact_id)    
+    def get_contact_by_id(contact_id)
+      get_contact(contact_id)
+    end
+
+    # Retrieve a contact from Xero
+    # Usage get_contact_by_id(contact_id)    
+    def get_contact_by_number(contact_number)
+      get_contact(nil, contact_number)
+    end
+    
+    # Factory method for building new Contact objects associated with this gateway.
+    def build_contact(contact = {})
+      case contact
+        when Contact then   contact.gateway = self
+        when Hash then      contact = Contact.new(contact.merge({:gateway => self}))
+      end
+      contact
+    end
+    
+    #
+    # Creates a contact in Xero
+    #
+    # Usage : 
+    #
+    # contact = XeroGateway::Contact.new(:name => "THE NAME OF THE CONTACT #{Time.now.to_i}")
+    # contact.email = "whoever@something.com"
+    # contact.phone.number = "12345"
+    # contact.address.line_1 = "LINE 1 OF THE ADDRESS"
+    # contact.address.line_2 = "LINE 2 OF THE ADDRESS"
+    # contact.address.line_3 = "LINE 3 OF THE ADDRESS"
+    # contact.address.line_4 = "LINE 4 OF THE ADDRESS"
+    # contact.address.city = "WELLINGTON"
+    # contact.address.region = "WELLINGTON"
+    # contact.address.country = "NEW ZEALAND"
+    # contact.address.post_code = "6021"
+    #
+    # create_contact(contact)
+    def create_contact(contact)
+      save_contact(contact)
+    end
+    
+    #
+    # Updates an existing Xero contact
+    #
+    # Usage : 
+    #
+    # contact = xero_gateway.get_contact(some_contact_id)
+    # contact.email = "a_new_email_ddress"
+    #
+    # xero_gateway.update_contact(contact)  
+    def update_contact(contact)
+      raise "contact_id or contact_number is required for updating contacts" if contact.contact_id.nil? and contact.contact_number.nil?
+      save_contact(contact)
+    end
+    
+    #
+    # Updates an array of contacts in a single API operation.
+    # 
+    # Usage :
+    #  contacts = [XeroGateway::Contact.new(:name => 'Joe Bloggs'), XeroGateway::Contact.new(:name => 'Jane Doe')]
+    #  result = gateway.update_contacts(contacts)
+    #
+    # Will update contacts with matching contact_id, contact_number or name or create if they don't exist.
+    #
+    def update_contacts(contacts)
+      b = Builder::XmlMarkup.new
+      request_xml = b.Contacts {
+        contacts.each do | contact |
+          contact.to_xml(b)
+        end
+      }
+      
+      response_xml = http_post(@client, "#{@xero_url}/Contacts", request_xml, {})
+
+      response = parse_response(response_xml, {:request_xml => request_xml}, {:request_signature => 'POST/contacts'})
+      response.contacts.each_with_index do | response_contact, index |
+        contacts[index].contact_id = response_contact.contact_id if response_contact && response_contact.contact_id
+      end
+      response
+    end
+    
+    # Retrieves all invoices from Xero
+    #
+    # Usage : get_invoices
+    #         get_invoices(:invoice_id => " 297c2dc5-cc47-4afd-8ec8-74990b8761e9")
+    #
+    # Note  : modified_since is in UTC format (i.e. Brisbane is UTC+10)
+    def get_invoices(options = {})
+      
+      request_params = {}
+      
+      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[:where]         = options[:where] if options[:where]
+
+      response_xml = http_get(@client, "#{@xero_url}/Invoices", request_params)
+
+      parse_response(response_xml, {:request_params => request_params}, {:request_signature => 'GET/Invoices'})
+    end
+    
+    # Retrieves a single invoice
+    #
+    # Usage : get_invoice("297c2dc5-cc47-4afd-8ec8-74990b8761e9") # By ID
+    #         get_invoice("OIT-12345") # By number
+    def get_invoice(invoice_id_or_number)
+      request_params = {}
+      
+      url  = "#{@xero_url}/Invoices/#{URI.escape(invoice_id_or_number)}"
+       
+      response_xml = http_get(@client, url, request_params)
+
+      parse_response(response_xml, {:request_params => request_params}, {:request_signature => 'GET/Invoice'})
+    end
+    
+    # Factory method for building new Invoice objects associated with this gateway.
+    def build_invoice(invoice = {})
+      case invoice
+        when Invoice then     invoice.gateway = self
+        when Hash then        invoice = Invoice.new(invoice.merge(:gateway => self))
+      end
+      invoice
+    end
+  
+    # Creates an invoice in Xero based on an invoice object.
+    #
+    # Invoice and line item totals are calculated automatically.
+    #
+    # Usage : 
+    #
+    #    invoice = XeroGateway::Invoice.new({
+    #      :invoice_type => "ACCREC",
+    #      :due_date => 1.month.from_now,
+    #      :invoice_number => "YOUR INVOICE NUMBER",
+    #      :reference => "YOUR REFERENCE (NOT NECESSARILY UNIQUE!)",
+    #      :line_amount_types => "Inclusive"
+    #    })
+    #    invoice.contact = XeroGateway::Contact.new(:name => "THE NAME OF THE CONTACT")
+    #    invoice.contact.phone.number = "12345"
+    #    invoice.contact.address.line_1 = "LINE 1 OF THE ADDRESS"    
+    #    invoice.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_invoice(invoice)
+    def create_invoice(invoice)
+      request_xml = invoice.to_xml
+      response_xml = http_put(@client, "#{@xero_url}/Invoices", request_xml)
+      response = parse_response(response_xml, {:request_xml => request_xml}, {:request_signature => 'PUT/invoice'})
+      
+      # Xero returns invoices inside an <Invoices> tag, even though there's only ever
+      # one for this request
+      response.response_item = response.invoices.first
+      
+      if response.success? && response.invoice && response.invoice.invoice_id
+        invoice.invoice_id = response.invoice.invoice_id 
+      end
+      
+      response
+    end
+    
+    #
+    # Creates an array of invoices with a single API request.
+    # 
+    # Usage :
+    #  invoices = [XeroGateway::Invoice.new(...), XeroGateway::Invoice.new(...)]
+    #  result = gateway.create_invoices(invoices)
+    #
+    def create_invoices(invoices)
+      b = Builder::XmlMarkup.new
+      request_xml = b.Invoices {
+        invoices.each do | invoice |
+          invoice.to_xml(b)
+        end
+      }
+      
+      response_xml = http_put(@client, "#{@xero_url}/Invoices", request_xml, {})
+
+      response = parse_response(response_xml, {:request_xml => request_xml}, {:request_signature => 'PUT/invoices'})
+      response.invoices.each_with_index do | response_invoice, index |
+        invoices[index].invoice_id = response_invoice.invoice_id if response_invoice && response_invoice.invoice_id
+      end
+      response
+    end
+
+    #
+    # Gets all accounts for a specific organization in Xero.
+    #
+    def get_accounts
+      response_xml = http_get(@client, "#{xero_url}/Accounts")
+      parse_response(response_xml, {}, {:request_signature => 'GET/accounts'})
+    end
+    
+    #
+    # Returns a XeroGateway::AccountsList object that makes working with
+    # the Xero list of accounts easier and allows caching the results.
+    #
+    def get_accounts_list(load_on_init = true)
+      AccountsList.new(self, load_on_init)
+    end
+
+    #
+    # Gets all tracking categories for a specific organization in Xero.
+    #
+    def get_tracking_categories
+      response_xml = http_get(@client, "#{xero_url}/TrackingCategories")
+
+      parse_response(response_xml, {}, {:request_signature => 'GET/TrackingCategories'})
+    end
+
+    #
+    # Gets Organisation details
+    #
+    def get_organisation
+      response_xml = http_get(@client, "#{xero_url}/Organisation")
+      parse_response(response_xml, {}, {:request_signature => 'GET/organisation'})
+    end
+    
+    #
+    # Gets all currencies for a specific organisation in Xero
+    #
+    def get_currencies
+      response_xml = http_get(@client, "#{xero_url}/Currencies")
+      parse_response(response_xml, {}, {:request_signature => 'GET/currencies'})
+    end
+    
+    #
+    # Gets all Tax Rates for a specific organisation in Xero
+    #
+    def get_tax_rates
+      response_xml = http_get(@client, "#{xero_url}/TaxRates")
+      parse_response(response_xml, {}, {:request_signature => 'GET/tax_rates'})
+    end
+
+    private
+
+    def get_contact(contact_id = nil, contact_number = nil)      
+      request_params = contact_id ? { :contactID => contact_id } : { :contactNumber => contact_number }
+      response_xml = http_get(@client, "#{@xero_url}/Contacts/#{URI.escape(contact_id||contact_number)}", request_params)
+
+      parse_response(response_xml, {:request_params => request_params}, {:request_signature => 'GET/contact'})
+    end
+    
+    # Create or update a contact record based on if it has a contact_id or contact_number.
+    def save_contact(contact)
+      request_xml = contact.to_xml
+      
+      response_xml = nil
+      create_or_save = nil
+      if contact.contact_id.nil? && contact.contact_number.nil?
+        # Create new contact record.
+        response_xml = http_put(@client, "#{@xero_url}/Contacts", request_xml, {})
+        create_or_save = :create
+      else
+        # Update existing contact record.
+        response_xml = http_post(@client, "#{@xero_url}/Contacts", request_xml, {})
+        create_or_save = :save
+      end
+
+      response = parse_response(response_xml, {:request_xml => request_xml}, {:request_signature => "#{create_or_save == :create ? 'PUT' : 'POST'}/contact"})
+      contact.contact_id = response.contact.contact_id if response.contact && response.contact.contact_id
+      response
+    end
+
+    def parse_response(raw_response, request = {}, options = {})
+
+      response = XeroGateway::Response.new
+
+      doc = REXML::Document.new(raw_response, :ignore_whitespace_nodes => :all)
+      
+      # check for responses we don't understand
+      raise UnparseableResponse.new(doc.root.name) unless doc.root.name == "Response"
+
+      response_element = REXML::XPath.first(doc, "/Response")
+          
+      response_element.children.reject { |e| e.is_a? REXML::Text }.each do |element|
+        case(element.name)
+          when "ID" then response.response_id = element.text
+          when "Status" then response.status = element.text
+          when "ProviderName" then response.provider = element.text
+          when "DateTimeUTC" then response.date_time = element.text
+          when "Contact" then response.response_item = Contact.from_xml(element, self)
+          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 "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) }
+          when "Organisations" then response.response_item = Organisation.from_xml(element.children.first) # Xero only returns the Authorized Organisation
+          when "TrackingCategories" then element.children.each {|child| response.response_item << TrackingCategory.from_xml(child) }
+          when "Errors" then element.children.each { |error| parse_error(error, response) }
+        end
+      end if response_element
+    
+      # If a single result is returned don't put it in an array
+      if response.response_item.is_a?(Array) && response.response_item.size == 1
+        response.response_item = response.response_item.first
+      end
+    
+      response.request_params = request[:request_params]
+      response.request_xml    = request[:request_xml]
+      response.response_xml   = raw_response
+      response
+    end    
+
+    def parse_error(error_element, response)
+      response.errors << Error.new(
+          :description => REXML::XPath.first(error_element, "Description").text,
+          :date_time => REXML::XPath.first(error_element, "//DateTime").text,
+          :type => REXML::XPath.first(error_element, "//ExceptionType").text,
+          :message => REXML::XPath.first(error_element, "//Message").text           
+      )
+    end
+  end  
+end