xeroizer-3-pre-beta 3.0.0.pre.beta

data/lib/xeroizer/http_encoding_helper.rb

@@ -0,0 +1,49 @@
+# Intended to extend the Net::HTTP response object
+# and adds support for decoding gzip and deflate encoded pages
+#
+# Author: Jason Stirk <http://griffin.oobleyboo.com>
+# Home: http://griffin.oobleyboo.com/projects/http_encoding_helper
+# Created: 5 September 2007
+# Last Updated: 23 November 2007
+#
+# Usage:
+#
+# require 'net/http'
+# require 'http_encoding_helper'
+# headers={'Accept-Encoding' => 'gzip, deflate' }
+# http = Net::HTTP.new('griffin.oobleyboo.com', 80)
+# http.start do |h|
+#   request = Net::HTTP::Get.new('/', headers)
+#   response = http.request(request)
+#   content=response.plain_body     # Method from our library
+#   puts "Transferred: #{response.body.length} bytes"
+#   puts "Compression: #{response['content-encoding']}"
+#   puts "Extracted: #{response.plain_body.length} bytes"  
+# end
+#	
+
+require 'zlib'
+require 'stringio'
+
+class Net::HTTPResponse
+  # Return the uncompressed content
+  def plain_body
+    encoding=self['content-encoding']
+    content=nil
+    if encoding then
+      case encoding
+        when 'gzip'
+          i=Zlib::GzipReader.new(StringIO.new(self.body))
+          content=i.read
+        when 'deflate'
+          i=Zlib::Inflate.new
+          content=i.inflate(self.body)
+        else
+          raise "Unknown encoding - #{encoding}"
+      end
+    else
+      content=self.body
+    end
+    return content
+  end
+end

data/lib/xeroizer/http_response.rb

@@ -0,0 +1,154 @@
+module Xeroizer
+  class BadResponse < XeroizerError; end
+
+  class XmlErrorResponse
+    def initialize(response, request_body, url)
+      @response = response
+      @request_body = request_body
+      @url = url
+    end
+
+    def raise_error!
+      case response.code.to_i
+      when 400
+        raise_bad_request!
+      when 401
+        raise_error
+      when 403
+        raise_error
+      when 404
+        raise_not_found!
+      when 429
+        raise_rate_limit_exceeded!
+      when 503
+        raise_error
+      else
+        raise_unknown_response_error!
+      end
+    end
+
+    def raise_error
+      description, problem = parse
+
+      # 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
+      # a second.
+      if problem
+        case problem
+        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)
+        when "consumer_key_unknown"         then raise OAuth::ConsumerKeyUnknown.new(description)
+        when "nonce_used"                   then raise OAuth::NonceUsed.new(description)
+        when "organisation offline"         then raise OAuth::OrganisationOffline.new(description)
+        else raise OAuth::UnknownError.new(problem + ':' + description)
+        end
+      else
+        raise OAuth::UnknownError.new("Xero API may be down or the way OAuth errors are provided by Xero may have changed.")
+      end
+    end
+
+    private
+
+    attr_reader :request_body, :response, :url
+
+    def parse
+      error_details = CGI.parse(response.plain_body)
+      description   = error_details["oauth_problem_advice"].first
+      problem = error_details["oauth_problem"].first
+      [description, problem]
+    end
+
+    def raise_bad_request!
+
+      raw_response = response.plain_body
+
+      # XeroGenericApplication 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)
+      doc = Nokogiri::XML(raw_response)
+
+      if doc && doc.root && (doc.root.name == "ApiException" || doc.root.name == 'Response')
+
+        raise ApiException.new(doc.root.xpath("Type").text,
+          doc.root.xpath("Message").text,
+          raw_response,
+          doc,
+          request_body)
+
+      else
+        raise Xeroizer::BadResponse.new("Unparseable 400 Response: #{raw_response}")
+      end
+    end
+
+    def raise_not_found!
+      case 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(url)
+      end
+    end
+
+    def raise_rate_limit_exceeded!
+      retry_after = response.response.headers["retry-after"].to_i
+      daily_limit_remaining = response.response.headers["x-daylimit-remaining"].to_i
+
+      description = "Rate limit exceeded: #{daily_limit_remaining} requests left for the day, #{retry_after} seconds until you can make another request"
+      raise OAuth::RateLimitExceeded.new(description, retry_after: retry_after, daily_limit_remaining: daily_limit_remaining)
+    end
+
+    def raise_unknown_response_error!
+      raise Xeroizer::BadResponse.new("Unknown response code: #{response.code.to_i}")
+    end
+  end
+
+  class HttpResponse
+    def self.from_response(response, request_body, url)
+      new(response, request_body, url)
+    end
+
+    def initialize(response, request_body, url)
+      @response = response
+      @request_body = request_body
+      @url = url
+    end
+
+    def body
+      response_code = response.code.to_i
+      return nil if response_code == 204
+      raise_error! unless response.code.to_i == 200
+      response.plain_body
+    end
+
+    private
+
+    def raise_error!
+      begin
+        error_details = JSON.parse(response.plain_body)
+        description  = error_details["Detail"]
+        case response.code.to_i
+        when 400
+          raise Xeroizer::BadResponse.new(description)
+        when 401
+          raise OAuth::TokenExpired.new(description) if description.include?("TokenExpired")
+          raise OAuth::TokenInvalid.new(description)
+        when 403
+          message = "Possible xero-tenant-id header issue. Xero Error: #{description}"
+          raise OAuth::Forbidden.new(message)
+        when 404
+          raise Xeroizer::ObjectNotFound.new(url)
+        else
+          raise Xeroizer::OAuth::UnknownError.new(description)
+        end
+      rescue JSON::ParserError
+        XmlErrorResponse.new(response, request_body, url).raise_error!
+      end
+    end
+
+    attr_reader :request_body, :response, :url
+  end
+end
+

data/lib/xeroizer/logging.rb

@@ -0,0 +1,8 @@
+module Xeroizer
+  module Logging
+    class DevNullLog; def self.info(what); end; end
+    class StdOutLog; def self.info(what); puts what; end; end
+
+    Log = DevNullLog
+  end
+end

data/lib/xeroizer/models/account.rb

@@ -0,0 +1,72 @@
+module Xeroizer
+  module Record
+
+    class AccountModel < BaseModel
+
+      set_permissions :read, :write
+
+      # The Accounts endpoint doesn't support the POST method yet.
+      def create_method
+        :http_put
+      end
+    end
+
+    class Account < Base
+
+      TYPE = {
+        'CURRENT' =>        '',
+        'FIXED' =>          '',
+        'PREPAYMENT' =>     '',
+        'EQUITY' =>         '',
+        'DEPRECIATN' =>     '',
+        'DIRECTCOSTS' =>    '',
+        'EXPENSE' =>        '',
+        'OVERHEADS' =>      '',
+        'CURRLIAB' =>       '',
+        'LIABILITY' =>      '',
+        'TERMLIAB' =>       '',
+        'OTHERINCOME' =>    '',
+        'REVENUE' =>        '',
+        'SALES' =>          ''
+      } unless defined?(TYPE)
+
+      TAX_TYPE = {
+        'NONE' =>             'No GST',
+        'EXEMPTINPUT' =>      'VAT on expenses exempt from VAT (UK only)',
+        'INPUT' =>            'GST on expenses',
+        'SRINPUT' =>          'VAT on expenses',
+        'ZERORATEDINPUT' =>   'Expense purchased from overseas (UK only)',
+        'RRINPUT' =>          'Reduced rate VAT on expenses (UK Only)',
+        'EXEMPTOUTPUT' =>     'VAT on sales exempt from VAT (UK only)',
+        'OUTPUT' =>           'OUTPUT',
+        'OUTPUT2' =>          'OUTPUT2',
+        'SROUTPUT' =>         'SROUTPUT',
+        'ZERORATEDOUTPUT' =>  'Sales made from overseas (UK only)',
+        'RROUTPUT' =>         'Reduced rate VAT on sales (UK Only)',
+        'ZERORATED' =>        'Zero-rated supplies/sales from overseas (NZ Only)',
+        'ECZROUTPUT' =>       'Zero-rated EC Income (UK only)'
+      } unless defined?(TAX_TYPE)
+
+      set_primary_key :account_id
+
+      guid    :account_id
+      string  :code
+      string  :name
+      string  :type
+      string  :class, :internal_name => :account_class
+      string  :status
+      string  :currency_code
+      string  :tax_type
+      string  :description
+      string  :system_account
+      boolean :enable_payments_to_account
+      boolean :show_in_expense_claims
+      string  :bank_account_number
+      string  :reporting_code
+      string  :reporting_code_name
+      datetime_utc :updated_date_utc, api_name: 'UpdatedDateUTC'
+
+    end
+
+  end
+end

data/lib/xeroizer/models/accounts_payable.rb

@@ -0,0 +1,13 @@
+module Xeroizer
+  module Record
+    
+    class AccountsPayableModel < BaseModel
+      set_permissions :read
+    end
+    
+    class AccountsPayable < Base
+      decimal :outstanding
+      decimal :overdue
+    end
+  end
+end

data/lib/xeroizer/models/accounts_receivable.rb

@@ -0,0 +1,13 @@
+module Xeroizer
+  module Record
+    
+    class AccountsReceivableModel < BaseModel
+      set_permissions :read
+    end
+    
+    class AccountsReceivable < Base
+      decimal :outstanding
+      decimal :overdue
+    end
+  end
+end

data/lib/xeroizer/models/address.rb

@@ -0,0 +1,41 @@
+module Xeroizer
+  module Record
+
+    class AddressModel < BaseModel
+
+    end
+
+    class Address < Base
+
+      ADDRESS_TYPE = {
+        'STREET' =>     'Street',
+        'POBOX' =>      'PO Box',
+        'DEFAULT' =>    'Default address type'
+      } unless defined?(ADDRESS_TYPE)
+
+      string :address_type, :internal_name => :type
+      string :attention_to
+      string :address_line1, :internal_name => :line1
+      string :address_line2, :internal_name => :line2
+      string :address_line3, :internal_name => :line3
+      string :address_line4, :internal_name => :line4
+      string :city
+      string :region
+      string :postal_code
+      string :country
+
+      validates_inclusion_of :type, :in => ADDRESS_TYPE.keys
+      validates_length_of :address_line1, :max => 500
+      validates_length_of :address_line2, :max => 500
+      validates_length_of :address_line3, :max => 500
+      validates_length_of :address_line4, :max => 500
+      validates_length_of :city, :max => 255
+      validates_length_of :region, :max => 255
+      validates_length_of :postal_code, :max => 50
+      validates_length_of :country, :max => 50
+      validates_length_of :attention_to, :max => 255
+
+    end
+
+  end
+end

data/lib/xeroizer/models/allocation.rb

@@ -0,0 +1,13 @@
+module Xeroizer
+  module Record
+    class AllocationModel < BaseModel
+    end
+
+    class Allocation < Base
+      decimal :applied_amount
+      belongs_to :invoice
+
+      validates_presence_of :invoice
+    end
+  end
+end

data/lib/xeroizer/models/attachment.rb

@@ -0,0 +1,95 @@
+module Xeroizer
+  module Record
+
+    class AttachmentModel < BaseModel
+
+      module Extensions
+        def attach_data(id, filename, data, content_type = "application/octet-stream", options = {})
+          application.Attachment.attach_data(url, id, filename, data, content_type, options)
+        end
+
+        def attach_file(id, filename, path, content_type = "application/octet-stream", options = {})
+          application.Attachment.attach_file(url, id, filename, path, content_type, options)
+        end
+
+        def attachments(id)
+          application.Attachment.attachments_for(url, id)
+        end
+      end
+
+      set_permissions :read
+
+      def attach_data(url, id, filename, data, content_type, options = {})
+        options = { include_online: false }.merge(options)
+
+        response_xml = @application.http_put(@application.client,
+                                              "#{url}/#{CGI.escape(id)}/Attachments/#{CGI.escape(filename)}",
+                                              data,
+                                              :raw_body => true, :content_type => content_type, "IncludeOnline" => options[:include_online]
+                                             )
+        response = parse_response(response_xml)
+        if (response_items = response.response_items) && response_items.size > 0
+          response_items.size == 1 ? response_items.first : response_items
+        else
+          response
+        end
+      end
+
+      def attach_file(url, id, filename, path, content_type, options = {})
+        attach_data(url, id, filename, File.read(path), content_type, options)
+      end
+
+      def attachments_for(url, id)
+        response_xml = @application.http_get(@application.client,
+                                             "#{url}/#{CGI.escape(id)}/Attachments")
+
+        response = parse_response(response_xml)
+        if (response_items = response.response_items) && response_items.size > 0
+          response_items
+        else
+          []
+        end
+      end
+
+    end
+
+    class Attachment < Base
+
+      module Extensions
+        def attach_file(filename, path, content_type = "application/octet-stream", options = {})
+          parent.attach_file(id, filename, path, content_type, options)
+        end
+
+        def attach_data(filename, data, content_type = "application/octet-stream", options = {})
+          parent.attach_data(id, filename, data, content_type, options)
+        end
+
+        def attachments
+          parent.attachments(id)
+        end
+      end
+
+      set_primary_key :attachment_id
+
+      guid    :attachment_id
+      string  :file_name
+      string  :url
+      string  :mime_type
+      integer :content_length
+
+      # Retrieve the attachment data.
+      # @param [String] filename optional filename to store the attachment in instead of returning the data.
+      def get(filename = nil)
+        data = parent.application.http_get(parent.application.client, url)
+        if filename
+          File.open(filename, "wb") { | fp | fp.write data }
+          nil
+        else
+          data
+        end
+      end
+
+    end
+
+  end
+end