xero_gateway 2.0.19 → 2.1.0

data/lib/xero_gateway/contact.rb

@@ -140,7 +140,7 @@ module XeroGateway
       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.Name self.name if 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
@@ -154,10 +154,10 @@ module XeroGateway
         b.DefaultCurrency if self.default_currency
         b.Addresses {
           addresses.each { |address| address.to_xml(b) }
-        }
+        } if self.addresses.any?
         b.Phones {
           phones.each { |phone| phone.to_xml(b) }
-        }
+        } if self.phones.any?
       }
     end
     

data/lib/xero_gateway/error.rb

@@ -14,5 +14,21 @@ module XeroGateway
       end
       return true
     end
+
+    # pass a REXML::Element error object to 
+    # have returned a new Error object
+    def self.parse(error_element)
+      description = REXML::XPath.first(error_element, "Description")
+      date = REXML::XPath.first(error_element, "//DateTime")
+      type = REXML::XPath.first(error_element, "//ExceptionType")
+      message = REXML::XPath.first(error_element, "//Message")
+      Error.new(
+        :description => (description.text if description),
+        :date_time => (date.text if date),
+        :type => (type.text if type),
+        :message => (message.text if message)
+      )
+    end
+
   end
 end

data/lib/xero_gateway/gateway.rb

@@ -1,22 +1,22 @@
 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, :expires_at, :authorization_expires_at
 
     #
     # The consumer key and secret here correspond to those provided
-    # to you by Xero inside the API Previewer. 
+    # 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
     #
@@ -34,27 +34,27 @@ module XeroGateway
 
       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[: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}/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)    
+    # 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)    
+    # 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
@@ -63,11 +63,11 @@ module XeroGateway
       end
       contact
     end
-    
+
     #
     # Creates a contact in Xero
     #
-    # Usage : 
+    # Usage :
     #
     # contact = XeroGateway::Contact.new(:name => "THE NAME OF THE CONTACT #{Time.now.to_i}")
     # contact.email = "whoever@something.com"
@@ -85,24 +85,24 @@ module XeroGateway
     def create_contact(contact)
       save_contact(contact)
     end
-    
+
     #
     # Updates an existing Xero contact
     #
-    # Usage : 
+    # Usage :
     #
     # contact = xero_gateway.get_contact(some_contact_id)
     # contact.email = "a_new_email_ddress"
     #
-    # xero_gateway.update_contact(contact)  
+    # 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)
@@ -116,7 +116,7 @@ module XeroGateway
           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'})
@@ -125,7 +125,7 @@ module XeroGateway
       end
       response
     end
-    
+
     # Retrieves all invoices from Xero
     #
     # Usage : get_invoices
@@ -133,12 +133,12 @@ module XeroGateway
     #
     # 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[:OrderBy]       = options[:order] if options[:order]
       request_params[:ModifiedAfter] = options[:modified_since] if options[:modified_since]
 
       request_params[:where]         = options[:where] if options[:where]
@@ -147,21 +147,33 @@ module XeroGateway
 
       parse_response(response_xml, {:request_params => request_params}, {:request_signature => 'GET/Invoices'})
     end
-    
+
     # Retrieves a single invoice
     #
+    # You can get a PDF-formatted invoice by specifying :pdf as the format argument
+    #
     # Usage : get_invoice("297c2dc5-cc47-4afd-8ec8-74990b8761e9") # By ID
     #         get_invoice("OIT-12345") # By number
-    def get_invoice(invoice_id_or_number)
+    def get_invoice(invoice_id_or_number, format = :xml)
       request_params = {}
-      
+      headers        = {}
+
+      headers.merge!("Accept" => "application/pdf") if format == :pdf
+
       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'})
+      response = http_get(@client, url, request_params, headers)
+
+      if format == :pdf
+        Tempfile.open(invoice_id_or_number) do |f|
+          f.write(response)
+          f
+        end
+      else
+        parse_response(response, {:request_params => request_params}, {:request_signature => 'GET/Invoice'})
+      end
     end
-    
+
     # Factory method for building new Invoice objects associated with this gateway.
     def build_invoice(invoice = {})
       case invoice
@@ -170,12 +182,12 @@ module XeroGateway
       end
       invoice
     end
-  
+
     # Creates an invoice in Xero based on an invoice object.
     #
     # Invoice and line item totals are calculated automatically.
     #
-    # Usage : 
+    # Usage :
     #
     #    invoice = XeroGateway::Invoice.new({
     #      :invoice_type => "ACCREC",
@@ -186,7 +198,7 @@ module XeroGateway
     #    })
     #    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.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,
@@ -203,12 +215,12 @@ module XeroGateway
     #
     # Updates an existing Xero invoice
     #
-    # Usage : 
+    # Usage :
     #
     # invoice = xero_gateway.get_invoice(some_invoice_id)
     # invoice.due_date = Date.today
     #
-    # xero_gateway.update_invoice(invoice)  
+    # xero_gateway.update_invoice(invoice)
 
     def update_invoice(invoice)
       raise "invoice_id is required for updating invoices" if invoice.invoice_id.nil?
@@ -217,7 +229,7 @@ module XeroGateway
 
     #
     # Creates an array of invoices with a single API request.
-    # 
+    #
     # Usage :
     #  invoices = [XeroGateway::Invoice.new(...), XeroGateway::Invoice.new(...)]
     #  result = gateway.create_invoices(invoices)
@@ -229,8 +241,8 @@ module XeroGateway
           invoice.to_xml(b)
         end
       }
-      
-      response_xml = http_put(@client, "#{@xero_url}/Invoices", request_xml, {})
+
+      response_xml = http_put(@client, "#{@xero_url}/Invoices?SummarizeErrors=false", request_xml, {})
 
       response = parse_response(response_xml, {:request_xml => request_xml}, {:request_signature => 'PUT/invoices'})
       response.invoices.each_with_index do | response_invoice, index |
@@ -246,12 +258,12 @@ module XeroGateway
     #
     # 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[:OrderBy]       = options[:order] if options[:order]
       request_params[:ModifiedAfter] = options[:modified_since] if options[:modified_since]
 
       request_params[:where]         = options[:where] if options[:where]
@@ -260,21 +272,21 @@ module XeroGateway
 
       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
@@ -283,12 +295,12 @@ module XeroGateway
       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 : 
+    # Usage :
     #
     #    credit_note = XeroGateway::CreditNote.new({
     #      :credit_note_type => "ACCREC",
@@ -299,7 +311,7 @@ module XeroGateway
     #    })
     #    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.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,
@@ -313,21 +325,21 @@ module XeroGateway
       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 
+        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)
@@ -339,7 +351,7 @@ module XeroGateway
           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'})
@@ -475,7 +487,7 @@ module XeroGateway
       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.
@@ -500,7 +512,7 @@ module XeroGateway
       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
     #
@@ -508,7 +520,7 @@ module XeroGateway
       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
     #
@@ -517,19 +529,33 @@ module XeroGateway
       parse_response(response_xml, {}, {:request_signature => 'GET/tax_rates'})
     end
 
+    #
+    # Create Payment record in Xero
+    #
+    def create_payment(payment)
+      b = Builder::XmlMarkup.new
+
+      request_xml = b.Payments do
+        payment.to_xml(b)
+      end
+
+      response_xml = http_put(@client, "#{xero_url}/Payments", request_xml)
+      parse_response(response_xml, {:request_xml => request_xml}, {:request_signature => 'PUT/payments'})
+    end
+
     private
 
-    def get_contact(contact_id = nil, contact_number = nil)      
+    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?
@@ -550,7 +576,7 @@ module XeroGateway
     # Create or update an invoice record based on if it has an invoice_id.
     def save_invoice(invoice)
       request_xml = invoice.to_xml
-      
+
       response_xml = nil
       create_or_save = nil
       if invoice.invoice_id.nil?
@@ -564,15 +590,15 @@ module XeroGateway
       end
 
       response = parse_response(response_xml, {:request_xml => request_xml}, {:request_signature => "#{create_or_save == :create ? 'PUT' : 'POST'}/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 
+        invoice.invoice_id = response.invoice.invoice_id
       end
-      
+
       response
     end
 
@@ -637,12 +663,12 @@ module XeroGateway
       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
@@ -671,28 +697,20 @@ module XeroGateway
           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) }
+          when "Errors" then response.errors = element.children.map { |error| Error.parse(error) }
         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
 end

data/lib/xero_gateway/http.rb

@@ -3,25 +3,25 @@ module XeroGateway
     OPEN_TIMEOUT = 10 unless defined? OPEN_TIMEOUT
     READ_TIMEOUT = 60 unless defined? READ_TIMEOUT
     ROOT_CA_FILE = File.join(File.dirname(__FILE__), 'ca-certificates.crt') unless defined? ROOT_CA_FILE
-    
-    def http_get(client, url, extra_params = {})
-      http_request(client, :get, url, nil, extra_params)
+
+    def http_get(client, url, extra_params = {}, headers = {})
+      http_request(client, :get, url, nil, extra_params, headers)
     end
 
-    def http_post(client, url, body, extra_params = {})
-      http_request(client, :post, url, body, extra_params)
+    def http_post(client, url, body, extra_params = {}, headers = {})
+      http_request(client, :post, url, body, extra_params, headers)
     end
 
-    def http_put(client, url, body, extra_params = {})
-      http_request(client, :put, url, body, extra_params)
+    def http_put(client, url, body, extra_params = {}, headers = {})
+      http_request(client, :put, url, body, extra_params, headers)
     end
-    
+
     private
-    
-      def http_request(client, method, url, body, params = {})
+
+      def http_request(client, method, url, body, params = {}, headers = {})
         # headers = {'Accept-Encoding' => 'gzip, deflate'}
 
-        headers = { 'charset' => 'utf-8' }
+        headers = headers.merge!('charset' => 'utf-8')
 
         if method != :get
           headers['Content-Type'] ||= "application/x-www-form-urlencoded"
@@ -38,39 +38,43 @@ module XeroGateway
 
         # # Only setup @cached_http once on first use as loading the CA file is quite expensive computationally.
         # unless @cached_http && @cached_http.address == uri.host && @cached_http.port == uri.port
-        #   @cached_http = Net::HTTP.new(uri.host, uri.port) 
+        #   @cached_http = Net::HTTP.new(uri.host, uri.port)
         #   @cached_http.open_timeout = OPEN_TIMEOUT
         #   @cached_http.read_timeout = READ_TIMEOUT
         #   @cached_http.use_ssl      = true
-        # 
+        #
         #   # Need to validate server's certificate against root certificate authority to prevent man-in-the-middle attacks.
         #   @cached_http.ca_file        = ROOT_CA_FILE
         #   # http.verify_mode    = OpenSSL::SSL::VERIFY_NONE
         #   @cached_http.verify_mode    = OpenSSL::SSL::VERIFY_PEER
         #   @cached_http.verify_depth   = 5
         # end
-        
+
         logger.info("\n== [#{Time.now.to_s}] XeroGateway Request: #{uri.request_uri} ") if self.logger
-        
+
         response = case method
           when :get   then    client.get(uri.request_uri, headers)
           when :post  then    client.post(uri.request_uri, { :xml => body }, headers)
           when :put   then    client.put(uri.request_uri, { :xml => body }, headers)
         end
-        
+
         if self.logger
           logger.info("== [#{Time.now.to_s}] XeroGateway Response (#{response.code})")
-          
+
           unless response.code.to_i == 200
             logger.info("== #{uri.request_uri} Response Body \n\n #{response.plain_body} \n == End Response Body")
           end
         end
-        
+
         case response.code.to_i
           when 200
-            response.plain_body
+            if RUBY_VERSION >= "1.9"
+              response.plain_body.force_encoding("UTF-8")
+            else
+              response.plain_body
+            end
           when 400
-            handle_error!(body, response)  
+            handle_error!(body, response)
           when 401
             handle_oauth_error!(response)
           when 404
@@ -79,11 +83,11 @@ module XeroGateway
             raise "Unknown response code: #{response.code.to_i}"
         end
       end
-       
+
       def handle_oauth_error!(response)
         error_details = CGI.parse(response.plain_body)
         description   = error_details["oauth_problem_advice"].first
-      
+
         # see http://oauth.pbworks.com/ProblemReporting
         # In addition to token_expired and token_rejected, Xero also returns
         # 'rate limit exceeded' when more than 60 requests have been made in
@@ -96,32 +100,32 @@ module XeroGateway
           else raise OAuth::UnknownError.new(error_details["oauth_problem"].first + ':' + description)
         end
       end
-      
+
       def handle_error!(request_xml, response)
-        
+
         raw_response = response.plain_body
-        
+
         # Xero Gateway API Exceptions *claim* to be UTF-16 encoded, but fail REXML/Iconv parsing...
         # So let's ignore that :)
         raw_response.gsub! '<?xml version="1.0" encoding="utf-16"?>', ''
-        
+
         doc = REXML::Document.new(raw_response, :ignore_whitespace_nodes => :all)
-        
+
         if doc.root.name == "ApiException"
 
-          raise ApiException.new(doc.root.elements["Type"].text, 
+          raise ApiException.new(doc.root.elements["Type"].text,
                                  doc.root.elements["Message"].text,
-                                 request_xml, 
+                                 request_xml,
                                  raw_response)
 
         else
-          
+
           raise "Unparseable 400 Response: #{raw_response}"
-          
+
         end
-        
+
       end
-      
+
       def handle_object_not_found!(response, request_url)
         case(request_url)
           when /Invoices/ then raise InvoiceNotFoundError.new("Invoice not found in Xero.")
@@ -130,6 +134,6 @@ module XeroGateway
           else raise ObjectNotFound.new(request_url)
         end
       end
-      
+
   end
 end

data/lib/xero_gateway/invoice.rb

@@ -30,13 +30,14 @@ module XeroGateway
     attr_accessor :gateway
     
     # Any errors that occurred when the #valid? method called.
-    attr_reader :errors
+    # Or errors that were within the XML payload from Xero
+    attr_accessor :errors
 
     # Represents whether the line_items have been downloaded when getting from GET /API.XRO/2.0/INVOICES
     attr_accessor :line_items_downloaded
   
     # All accessible fields
-    attr_accessor :invoice_id, :invoice_number, :invoice_type, :invoice_status, :date, :due_date, :reference, :line_amount_types, :currency_code, :line_items, :contact, :payments, :fully_paid_on, :amount_due, :amount_paid, :amount_credited, :sent_to_contact, :url
+    attr_accessor :invoice_id, :invoice_number, :invoice_type, :invoice_status, :date, :due_date, :reference, :branding_theme_id, :line_amount_types, :currency_code, :line_items, :contact, :payments, :fully_paid_on, :amount_due, :amount_paid, :amount_credited, :sent_to_contact, :url
 
     
     def initialize(params = {})
@@ -66,6 +67,10 @@ module XeroGateway
     def valid?
       @errors = []
       
+      if !INVOICE_TYPE[invoice_type]
+        @errors << ['invoice_type', "must be one of #{INVOICE_TYPE.keys.join('/')}"]
+      end
+
       if !invoice_id.nil? && invoice_id !~ GUID_REGEX
         @errors << ['invoice_id', 'must be blank or a valid Xero GUID']
       end
@@ -187,6 +192,7 @@ module XeroGateway
         b.DueDate Invoice.format_date(self.due_date) if self.due_date
         b.Status self.invoice_status if self.invoice_status
         b.Reference self.reference if self.reference
+        b.BrandingThemeID self.branding_theme_id if self.branding_theme_id
         b.LineAmountTypes self.line_amount_types
         b.LineItems {
           self.line_items.each do |line_item|
@@ -211,22 +217,24 @@ module XeroGateway
           when "DueDate" then invoice.due_date = parse_date(element.text)
           when "Status" then invoice.invoice_status = element.text
           when "Reference" then invoice.reference = element.text
+          when "BrandingThemeID" then invoice.branding_theme_id = element.text
           when "LineAmountTypes" then invoice.line_amount_types = element.text
           when "LineItems" then element.children.each {|line_item| invoice.line_items_downloaded = true; invoice.line_items << LineItem.from_xml(line_item) }
           when "SubTotal" then invoice.sub_total = BigDecimal.new(element.text)
           when "TotalTax" then invoice.total_tax = BigDecimal.new(element.text)
           when "Total" then invoice.total = BigDecimal.new(element.text)
           when "InvoiceID" then invoice.invoice_id = element.text
-          when "InvoiceNumber" then invoice.invoice_number = element.text            
+          when "InvoiceNumber" then invoice.invoice_number = element.text
           when "Payments" then element.children.each { | payment | invoice.payments << Payment.from_xml(payment) }
           when "AmountDue" then invoice.amount_due = BigDecimal.new(element.text)
           when "AmountPaid" then invoice.amount_paid = BigDecimal.new(element.text)
           when "AmountCredited" then invoice.amount_credited = BigDecimal.new(element.text)
           when "SentToContact" then invoice.sent_to_contact = (element.text.strip.downcase == "true")
           when "Url" then invoice.url = element.text
+          when "ValidationErrors" then invoice.errors = element.children.map { |error| Error.parse(error) }
         end
-      end      
+      end
       invoice
-    end    
+    end
   end
 end

data/lib/xero_gateway/oauth.rb

@@ -1,18 +1,18 @@
 module XeroGateway
-  
+
   # Shamelessly based on the Twitter Gem's OAuth implementation by John Nunemaker
   # Thanks!
-  # 
+  #
   # http://twitter.rubyforge.org/
   # http://github.com/jnunemaker/twitter/
-  
+
   class OAuth
-    
+
     class TokenExpired < StandardError; end
     class TokenInvalid < StandardError; end
     class RateLimitExceeded < StandardError; end
     class UnknownError < StandardError; end
-        
+
     unless defined? XERO_CONSUMER_OPTIONS
       XERO_CONSUMER_OPTIONS = {
         :site               => "https://api.xero.com",
@@ -21,54 +21,55 @@ module XeroGateway
         :authorize_path     => "/oauth/Authorize"
       }.freeze
     end
-    
+
     extend Forwardable
     def_delegators :access_token, :get, :post, :put, :delete
-    
-    attr_reader :ctoken, :csecret, :consumer_options, :session_handle, :expires_at, :authorization_expires_at
-    
+
+    attr_reader   :ctoken, :csecret, :consumer_options, :authorization_expires_at
+    attr_accessor :session_handle
+
     def initialize(ctoken, csecret, options = {})
       @ctoken, @csecret = ctoken, csecret
       @consumer_options = XERO_CONSUMER_OPTIONS.merge(options)
     end
-    
+
     def consumer
       @consumer ||= ::OAuth::Consumer.new(@ctoken, @csecret, consumer_options)
     end
-    
+
     def request_token(params = {})
       @request_token ||= consumer.get_request_token(params)
     end
-    
+
     def authorize_from_request(rtoken, rsecret, params = {})
       request_token     = ::OAuth::RequestToken.new(consumer, rtoken, rsecret)
       access_token      = request_token.get_access_token(params)
       @atoken, @asecret = access_token.token, access_token.secret
-      
+
       update_attributes_from_token(access_token)
     end
-    
+
     def access_token
       @access_token ||= ::OAuth::AccessToken.new(consumer, @atoken, @asecret)
     end
-    
+
     def authorize_from_access(atoken, asecret)
       @atoken, @asecret = atoken, asecret
     end
-  
+
     # Renewing access tokens only works for Partner applications
     def renew_access_token(access_token = nil, access_secret = nil, session_handle = nil)
       access_token   ||= @atoken
-      access_secret  ||= @asecret 
+      access_secret  ||= @asecret
       session_handle ||= @session_handle
-      
+
       old_token = ::OAuth::RequestToken.new(consumer, access_token, access_secret)
-      
+
       access_token = old_token.get_access_token({
         :oauth_session_handle => session_handle,
         :token                => old_token
       })
-      
+
       update_attributes_from_token(access_token)
     rescue ::OAuth::Unauthorized => e
       # If the original access token is for some reason invalid an OAuth::Unauthorized could be raised.
@@ -76,9 +77,9 @@ module XeroGateway
       # situation the end user will need to re-authorize the application via the request token authorization URL
       raise XeroGateway::OAuth::TokenInvalid.new(e.message)
     end
-    
+
     private
-    
+
       # Update instance variables with those from the AccessToken.
       def update_attributes_from_token(access_token)
         @expires_at               = Time.now + access_token.params[:oauth_expires_in].to_i
@@ -87,6 +88,6 @@ module XeroGateway
         @atoken, @asecret         = access_token.token, access_token.secret
         @access_token             = nil
       end
-    
+
   end
 end

data/lib/xero_gateway/partner_app.rb

@@ -6,7 +6,7 @@ module XeroGateway
     NO_SSL_CLIENT_CERT_MESSAGE   = "You need to provide a client ssl certificate and key pair (these are the ones you got from Entrust and should not be password protected) as :ssl_client_cert and :ssl_client_key (should be .crt or .pem files)"
     NO_PRIVATE_KEY_ERROR_MESSAGE = "You need to provide your private key (corresponds to the public key you uploaded at api.xero.com) as :private_key_file (should be .crt or .pem files)"
     
-    def_delegators :client, :session_handle, :renew_access_token
+    def_delegators :client, :session_handle, :renew_access_token, :authorization_expires_at
      
     def initialize(consumer_key, consumer_secret, options = {})
       
@@ -26,5 +26,10 @@ module XeroGateway
       @xero_url = options[:xero_url] || "https://api-partner.xero.com/api.xro/2.0"  
       @client   = OAuth.new(consumer_key, consumer_secret, options)
     end
+
+    def set_session_handle(handle)
+      client.session_handle = handle
+    end
+    
   end
 end

data/lib/xero_gateway/payment.rb

@@ -7,16 +7,16 @@ module XeroGateway
     attr_reader :errors
 
     # All accessible fields
-    attr_accessor :payment_id, :date, :amount, :reference, :currency_rate
-        
+    attr_accessor :invoice_id, :invoice_number, :account_id, :code, :payment_id, :date, :amount, :reference, :currency_rate
+
     def initialize(params = {})
       @errors ||= []
-            
+
       params.each do |k,v|
         self.send("#{k}=", v)
       end
     end
-    
+
     def self.from_xml(payment_element)
       payment = Payment.new
       payment_element.children.each do | element |
@@ -26,18 +26,45 @@ module XeroGateway
           when 'Amount'       then payment.amount = BigDecimal.new(element.text)
           when 'Reference'    then payment.reference = element.text
           when 'CurrencyRate' then payment.currency_rate = BigDecimal.new(element.text)
-        end    
+          when 'Invoice'      then payment.send("#{element.children.first.name.underscore}=", element.children.first.text)
+          when 'Account'      then payment.send("#{element.children.first.name.underscore}=", element.children.first.text)
+        end
       end
       payment
-    end 
-    
+    end
+
     def ==(other)
       [:payment_id, :date, :amount].each do |field|
         return false if send(field) != other.send(field)
       end
       return true
     end
-    
+
+    def to_xml(b = Builder::XmlMarkup.new)
+      b.Payment do
+
+        if self.invoice_id || self.invoice_number
+          b.Invoice do |i|
+            i.InvoiceID         self.invoice_id     if self.invoice_id
+            i.InvoiceNumber     self.invoice_number if self.invoice_number
+          end
+        end
+
+        if self.account_id || self.code
+          b.Account do |a|
+            a.AccountID         self.account_id     if self.account_id
+            a.Code              self.code           if self.code
+          end
+        end
+
+        b.Amount            self.amount         if self.amount
+        b.CurrencyRate      self.currency_rate  if self.currency_rate
+        b.Reference         self.reference      if self.reference
+
+        b.Date              self.class.format_date(self.date || Date.today)
+      end
+    end
+
 
   end
 end

data/lib/xero_gateway/tax_rate.rb

@@ -47,7 +47,7 @@ module XeroGateway
           attribute             = element.name
           underscored_attribute = element.name.underscore
         
-          raise "Unknown attribute: #{attribute}" unless ATTRS.keys.include?(attribute)
+          next if !ATTRS.keys.include?(attribute)
         
           case (ATTRS[attribute])
             when :boolean then  tax_rate.send("#{underscored_attribute}=", (element.text == "true"))

data/lib/xero_gateway.rb

@@ -8,6 +8,7 @@ require "oauth"
 require 'oauth/signature/rsa/sha1'
 require "forwardable"
 require "active_support/all"
+require "tempfile"
 
 require File.join(File.dirname(__FILE__), 'oauth', 'oauth_consumer')
 

data/test/integration/create_invoice_test.rb

@@ -33,6 +33,12 @@ class CreateInvoiceTest < Test::Unit::TestCase
     example_invoice = dummy_invoice.dup
     assert_equal true, example_invoice.valid?, "invoice is invalid - errors:\n\t#{example_invoice.errors.map { | error | "#{error[0]} #{error[1]}"}.join("\n\t")}"
   end
+
+  def test_create_invoice_invalid_with_invalid_invoice_type
+    example_invoice = dummy_invoice.dup
+    example_invoice.invoice_type = "ABC"
+    assert_equal false, example_invoice.valid?
+  end
   
   private
   

data/test/integration/create_payments_test.rb

@@ -0,0 +1,35 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class CreatePaymentsTest < Test::Unit::TestCase
+  include TestHelper
+
+  def setup
+    @gateway = XeroGateway::Gateway.new(CONSUMER_KEY, CONSUMER_SECRET)
+
+    if STUB_XERO_CALLS
+      @gateway.xero_url = "DUMMY_URL"
+
+      @gateway.stubs(:http_put).with {|client, url, body, params| url =~ /Invoices$/ }.returns(get_file_as_string("create_invoice.xml"))
+      @gateway.stubs(:http_put).with {|client, url, params| url =~ /Payments$/ }.returns(get_file_as_string("create_payments.xml"))
+    end
+  end
+
+  def test_create_payment
+    example_invoice = dummy_invoice.dup
+
+    result = @gateway.create_invoice(example_invoice)
+
+    payment = XeroGateway::Payment.new(
+      :invoice_id => result.invoice.invoice_id,
+      :amount     => 500,
+      :reference  => "Test Payment",
+      :date       => Time.now,
+      :code       => "601"
+    )
+
+    result = @gateway.create_payment(payment)
+
+    assert_kind_of XeroGateway::Response, result
+    assert result.success?
+  end
+end

data/test/integration/get_invoice_test.rb

@@ -2,18 +2,25 @@ require File.dirname(__FILE__) + '/../test_helper'
 
 class GetInvoiceTest < Test::Unit::TestCase
   include TestHelper
-  
+
+  INVOICE_GET_URL = /Invoices(\/[0-9a-z\-]+)?$/i
+
   def setup
     @gateway = XeroGateway::Gateway.new(CONSUMER_KEY, CONSUMER_SECRET)
-    
+
     if STUB_XERO_CALLS
       @gateway.xero_url = "DUMMY_URL"
-      
-      @gateway.stubs(:http_get).with {|client, url, params| url =~ /Invoices(\/[0-9a-z\-]+)?$/i }.returns(get_file_as_string("invoice.xml"))              
-      @gateway.stubs(:http_put).with {|client, url, body, params| url =~ /Invoices$/ }.returns(get_file_as_string("create_invoice.xml"))          
+
+      @gateway.stubs(:http_get).with do |client, url, params, headers|
+        url =~ INVOICE_GET_URL && headers["Accept"] == "application/pdf"
+      end.returns(get_file_as_string("get_invoice.pdf"))
+
+      @gateway.stubs(:http_get).with {|client, url, params, headers| url =~ INVOICE_GET_URL && headers["Accept"].blank? }.returns(get_file_as_string("invoice.xml"))
+      @gateway.stubs(:http_put).with {|client, url, body, params| url =~ /Invoices$/ }.returns(get_file_as_string("create_invoice.xml"))
+
     end
   end
-  
+
   def test_get_invoice
     # Make sure there is an invoice in Xero to retrieve
     invoice = @gateway.create_invoice(dummy_invoice).invoice
@@ -21,28 +28,36 @@ class GetInvoiceTest < Test::Unit::TestCase
     result = @gateway.get_invoice(invoice.invoice_id)
     assert result.success?
     assert !result.request_params.nil?
-    assert !result.response_xml.nil?    
+    assert !result.response_xml.nil?
     assert_equal result.invoice.invoice_number, invoice.invoice_number
 
     result = @gateway.get_invoice(invoice.invoice_number)
     assert result.success?
     assert !result.request_params.nil?
-    assert !result.response_xml.nil?    
+    assert !result.response_xml.nil?
     assert_equal result.invoice.invoice_id, invoice.invoice_id
   end
-  
+
   def test_line_items_downloaded_set_correctly
     # Make sure there is an invoice in Xero to retrieve.
     example_invoice = @gateway.create_invoice(dummy_invoice).invoice
-    
+
     # No line items.
     response = @gateway.get_invoice(example_invoice.invoice_id)
     assert_equal(true, response.success?)
-    
+
     invoice = response.invoice
     assert_kind_of(XeroGateway::LineItem, invoice.line_items.first)
     assert_kind_of(XeroGateway::Invoice, invoice)
     assert_equal(true, invoice.line_items_downloaded?)
   end
-  
+
+  def test_get_invoice_pdf
+    # Make sure there is an invoice in Xero to retrieve
+    example_invoice = @gateway.create_invoice(dummy_invoice).invoice
+
+    pdf_tempfile = @gateway.get_invoice(example_invoice.invoice_id, :pdf)
+    assert_equal get_file_as_string("get_invoice.pdf"), File.open(pdf_tempfile.path).read
+  end
+
 end

data/test/unit/gateway_test.rb

@@ -6,28 +6,28 @@ class GatewayTest < Test::Unit::TestCase
   def setup
     @gateway = XeroGateway::Gateway.new(CONSUMER_KEY, CONSUMER_SECRET)
   end
-  
+
   context "with error handling" do
-    
+
     should "handle token expired" do
       XeroGateway::OAuth.any_instance.stubs(:get).returns(stub(:plain_body => get_file_as_string("token_expired"), :code => "401"))
-      
+
       assert_raises XeroGateway::OAuth::TokenExpired do
         @gateway.get_accounts
       end
     end
-    
+
     should "handle invalid request tokens" do
       XeroGateway::OAuth.any_instance.stubs(:get).returns(stub(:plain_body => get_file_as_string("invalid_request_token"), :code => "401"))
-      
+
       assert_raises XeroGateway::OAuth::TokenInvalid do
         @gateway.get_accounts
       end
     end
-    
+
     should "handle invalid consumer key" do
      XeroGateway::OAuth.any_instance.stubs(:get).returns(stub(:plain_body => get_file_as_string("invalid_consumer_key"), :code => "401"))
-      
+
       assert_raises XeroGateway::OAuth::TokenInvalid do
         @gateway.get_accounts
       end
@@ -48,10 +48,10 @@ class GatewayTest < Test::Unit::TestCase
         @gateway.get_accounts
       end
     end
-    
+
     should "handle ApiExceptions" do
       XeroGateway::OAuth.any_instance.stubs(:put).returns(stub(:plain_body => get_file_as_string("api_exception.xml"), :code => "400"))
-      
+
       assert_raises XeroGateway::ApiException do
         @gateway.create_invoice(XeroGateway::Invoice.new)
       end
@@ -86,17 +86,17 @@ class GatewayTest < Test::Unit::TestCase
 
       assert_raises XeroGateway::UnparseableResponse do
         @gateway.create_invoice(XeroGateway::Invoice.new)
-      end      
+      end
     end
-    
+
   end
-  
+
   def test_unknown_error_handling
     if STUB_XERO_CALLS
       @gateway.xero_url = "DUMMY_URL"
-      @gateway.stubs(:http_get).with {|client, url, params| url =~ /Invoices\/AN_INVALID_ID$/ }.returns(get_file_as_string("unknown_error.xml"))          
+      @gateway.stubs(:http_get).with {|client, url, params| url =~ /Invoices\/AN_INVALID_ID$/ }.returns(get_file_as_string("unknown_error.xml"))
     end
-    
+
     result = @gateway.get_invoice("AN_INVALID_ID")
     assert !result.success?
     assert_equal 1, result.errors.size
@@ -109,7 +109,7 @@ class GatewayTest < Test::Unit::TestCase
       @gateway.xero_url = "DUMMY_URL"
       @gateway.stubs(:http_get).with {|client, url, params| url =~ /Invoices\/UNKNOWN_INVOICE_NO$/ }.returns(get_file_as_string("invoice_not_found_error.xml"))
     end
-    
+
     result = @gateway.get_invoice("UNKNOWN_INVOICE_NO")
     assert !result.success?
     assert_equal 1, result.errors.size

data/test/unit/invoice_test.rb

@@ -240,8 +240,9 @@ class InvoiceTest < Test::Unit::TestCase
   end
 
   def test_optional_params
-    invoice = create_test_invoice(:url => 'http://example.com')
+    invoice = create_test_invoice(:url => 'http://example.com', :branding_theme_id => 'a94a78db-5cc6-4e26-a52b-045237e56e6e')
     assert_equal 'http://example.com', invoice.url
+    assert_equal 'a94a78db-5cc6-4e26-a52b-045237e56e6e', invoice.branding_theme_id
   end
 
   private

data/test/unit/payment_test.rb

@@ -0,0 +1,34 @@
+require File.join(File.dirname(__FILE__), '../test_helper.rb')
+
+class PaymentTest < Test::Unit::TestCase
+
+  # Tests that a payment can be converted into XML that Xero can understand, and then converted back to a payment
+  def test_build_and_parse_xml
+    payment = create_test_payment
+
+    # Generate the XML message
+    payment_as_xml = payment.to_xml
+
+    # Parse the XML message and retrieve the account element
+    payment_element = REXML::XPath.first(REXML::Document.new(payment_as_xml), "/Payment")
+
+    # Build a new account from the XML
+    result_payment = XeroGateway::Payment.from_xml(payment_element)
+
+    # Check the details
+    assert_equal payment, result_payment
+  end
+
+
+  private
+
+  def create_test_payment
+    XeroGateway::Payment.new.tap do |payment|
+      payment.invoice_id        = "a99a9aaa-9999-99a9-9aa9-aaaaaa9a9999"
+      payment.amount            = 100.0
+      payment.date              = Time.now.beginning_of_day
+      payment.reference         = "Invoice Payment"
+      payment.code              = 200
+    end
+  end
+end

data/xero_gateway.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
   s.name     = "xero_gateway"
-  s.version  = "2.0.19"
-  s.date     = "2012-07-13"
+  s.version  = "2.1.0"
+  s.date     = "2012-11-19"
   s.summary  = "Enables ruby based applications to communicate with the Xero API"
   s.email    = "tim@connorsoftware.com"
   s.homepage = "http://github.com/tlconnor/xero_gateway"

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: xero_gateway
 version: !ruby/object:Gem::Version 
-  hash: 41
+  hash: 11
   prerelease: 
   segments: 
   - 2
+  - 1
   - 0
-  - 19
-  version: 2.0.19
+  version: 2.1.0
 platform: ruby
 authors: 
 - Tim Connor
@@ -16,8 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-07-13 00:00:00 +12:00
-default_executable: 
+date: 2012-11-19 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: builder
@@ -118,6 +117,7 @@ files:
 - test/integration/create_credit_note_test.rb
 - test/integration/create_invoice_test.rb
 - test/integration/create_manual_journal_test.rb
+- test/integration/create_payments_test.rb
 - test/integration/get_accounts_test.rb
 - test/integration/get_bank_transaction_test.rb
 - test/integration/get_bank_transactions_test.rb
@@ -148,10 +148,10 @@ files:
 - test/unit/manual_journal_test.rb
 - test/unit/oauth_test.rb
 - test/unit/organisation_test.rb
+- test/unit/payment_test.rb
 - test/unit/tax_rate_test.rb
 - test/unit/tracking_category_test.rb
 - lib/xero_gateway/ca-certificates.crt
-has_rdoc: true
 homepage: http://github.com/tlconnor/xero_gateway
 licenses: []
 
@@ -181,7 +181,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.6.2
+rubygems_version: 1.8.15
 signing_key: 
 specification_version: 3
 summary: Enables ruby based applications to communicate with the Xero API