xeroizer 2.16.5 → 2.17.1

data/lib/xeroizer/models/payroll/employee.rb

@@ -0,0 +1,45 @@
+module Xeroizer
+  module Record
+    module Payroll
+    
+      class EmployeeModel < PayrollBaseModel
+          
+        set_permissions :read, :write, :update
+          
+      end
+      
+      class Employee < PayrollBase
+        
+        set_primary_key :employee_id
+
+        guid          :employee_id
+        string        :status
+        string        :title
+        string        :first_name
+        string        :middle_names
+        string        :last_name
+        date          :start_date
+        string        :email
+        date          :date_of_birth
+        string        :gender
+        string        :phone
+        string        :mobile
+        string        :twitter_user_name
+        boolean       :is_authorised_to_approve_leave
+        boolean       :is_authorised_to_approve_timesheets
+        string        :occupation
+        string        :classification
+        guid          :ordinary_earnings_rate_id
+        guid          :payroll_calendar_id
+        string        :employee_group_name
+        date          :termination_date
+        datetime_utc  :updated_date_utc, :api_name => 'UpdatedDateUTC'
+  
+        belongs_to    :home_address, :internal_name_singular => "home_address", :model_name => "HomeAddress"
+        has_many      :bank_accounts
+
+      end
+
+    end 
+  end
+end

data/lib/xeroizer/models/payroll/home_address.rb

@@ -0,0 +1,24 @@
+module Xeroizer
+  module Record
+    module Payroll
+    
+      class HomeAddressModel < PayrollBaseModel
+          
+      end
+      
+      class HomeAddress < PayrollBase
+        
+        string      :address_line_1
+        string      :address_line_2
+        string      :address_line_3
+        string      :address_line_4
+        string      :city
+        string      :region
+        string      :postal_code
+        string      :country
+
+      end
+
+    end 
+  end
+end

data/lib/xeroizer/models/prepayment.rb

@@ -29,6 +29,7 @@ module Xeroizer
 
       belongs_to    :contact
       has_many      :line_items
+      has_many      :payments
 
       def contact_id
         contact.id if contact

data/lib/xeroizer/models/tax_rate.rb

@@ -1,10 +1,10 @@
 module Xeroizer
   module Record
-    
+
     class TaxRateModel < BaseModel
-            
+
       set_permissions :read
-      
+
       # TaxRates can be created using either POST or PUT.
       # POST will also silently update the tax, which can
       # be unexpected.  PUT is only for create.
@@ -12,13 +12,14 @@ module Xeroizer
         :http_put
       end
     end
-    
+
     class TaxRate < Base
       set_primary_key :name
       set_possible_primary_keys :tax_type, :name
 
       string  :name
       string  :tax_type
+      string  :report_tax_type # Read-only except for AU, NZ, and UK versions
       string  :status
       boolean :can_apply_to_assets
       boolean :can_apply_to_equity

data/lib/xeroizer/models/to_bank_account.rb

@@ -0,0 +1,12 @@
+module Xeroizer
+  module Record
+    class ToBankAccountModel < BaseModel
+      set_permissions :read
+    end
+
+    class ToBankAccount < Base
+      guid   :account_id
+      string :code
+    end
+  end
+end

data/lib/xeroizer/oauth.rb

@@ -23,13 +23,14 @@ module Xeroizer
   # http://github.com/jnunemaker/twitter/
 
   class OAuth
-
-    class TokenExpired < StandardError; end
-    class TokenInvalid < StandardError; end
-    class RateLimitExceeded < StandardError; end
-    class ConsumerKeyUnknown < StandardError; end
-    class NonceUsed < StandardError; end
-    class UnknownError < StandardError; end
+    class OAuthError < XeroizerError; end
+    class TokenExpired < OAuthError; end
+    class TokenInvalid < OAuthError; end
+    class RateLimitExceeded < OAuthError; end
+    class ConsumerKeyUnknown < OAuthError; end
+    class NonceUsed < OAuthError; end
+    class OrganisationOffline < OAuthError; end
+    class UnknownError < OAuthError; end
 
     unless defined? XERO_CONSUMER_OPTIONS
       XERO_CONSUMER_OPTIONS = {
@@ -132,7 +133,6 @@ module Xeroizer
           consumer.http.cert = @consumer_options[:ssl_client_cert]
           consumer.http.key = @consumer_options[:ssl_client_key]
         end
-        consumer
 
         if @consumer_options[:http_debug_output]
           consumer.http.set_debug_output(@consumer_options[:http_debug_output])

data/lib/xeroizer/partner_application.rb

@@ -13,21 +13,17 @@ module Xeroizer
       # @param [String] consumer_key consumer key/token from application developer (found at http://api.xero.com for your application).
       # @param [String] consumer_secret consumer secret from application developer (found at http://api.xero.com for your application).
       # @param [String] path_to_private_key application's private key for message signing (uploaded to http://api.xero.com)
-      # @param [String] ssl_client_cert client-side SSL certificate file to use for requests
-      # @param [String] ssl_client_key client-side SSL private key to use for requests
       # @param [Hash] options other options to pass to the GenericApplication constructor
       # @return [PartnerApplication] instance of PrivateApplication
-      def initialize(consumer_key, consumer_secret, path_to_private_key, ssl_client_cert, ssl_client_key, options = {})
+      def initialize(consumer_key, consumer_secret, path_to_private_key, options = {})
         default_options = {
-          :xero_url         => 'https://api-partner.network.xero.com/api.xro/2.0',
-          :site             => 'https://api-partner.network.xero.com',
+          :xero_url         => 'https://api.xero.com/api.xro/2.0',
+          :site             => 'https://api.xero.com',
           :authorize_url    => 'https://api.xero.com/oauth/Authorize',
           :signature_method => 'RSA-SHA1'
         }
         options = default_options.merge(options).merge(
-          :private_key_file => path_to_private_key,
-          :ssl_client_cert  => OpenSSL::X509::Certificate.new(read_certificate(ssl_client_cert)),
-          :ssl_client_key   => OpenSSL::PKey::RSA.new(read_certificate(ssl_client_key))
+          :private_key_file => path_to_private_key
         )
         super(consumer_key, consumer_secret, options)
 

data/lib/xeroizer/payroll_application.rb

@@ -0,0 +1,28 @@
+module Xeroizer
+  class PayrollApplication
+    
+    attr_reader :application
+
+    # Factory for new Payroll BaseModel instances with the class name `record_type`.
+    # Only creates the instance if one doesn't already exist.
+    #
+    # @param [Symbol] record_type Symbol of the record type (e.g. :Invoice)
+    # @return [BaseModel] instance of BaseModel subclass matching `record_type`
+    def self.record(record_type)
+      define_method record_type do
+        var_name = "@#{record_type}_cache".to_sym
+        unless instance_variable_defined?(var_name)
+          instance_variable_set(var_name, Xeroizer::Record::Payroll.const_get("#{record_type}Model".to_sym).new(self.application, record_type.to_s))
+        end
+        instance_variable_get(var_name)
+      end  
+    end
+
+    record :Employee
+    
+    def initialize(application)
+      @application = application
+    end
+
+  end
+end

data/lib/xeroizer/private_application.rb

@@ -15,10 +15,8 @@ module Xeroizer
       # @param [Hash] options other options to pass to the GenericApplication constructor
       # @return [PrivateApplication] instance of PrivateApplication
       def initialize(consumer_key, consumer_secret, path_to_private_key, options = {})
-        options.merge!(
-          :signature_method => 'RSA-SHA1',
-          :private_key_file => path_to_private_key
-        )
+        options[:signature_method] = 'RSA-SHA1'
+        options[:private_key_file] = path_to_private_key
         super(consumer_key, consumer_secret, options)
         @client.authorize_from_access(consumer_key, consumer_secret)
       end

data/lib/xeroizer/record/base_model.rb

@@ -9,7 +9,7 @@ module Xeroizer
       class_inheritable_attributes :api_controller_name
 
       module InvaidPermissionError; end
-      class InvalidPermissionError < StandardError
+      class InvalidPermissionError < XeroizerError
         include InvaidPermissionError
       end
       ALLOWED_PERMISSIONS = [:read, :write, :update]
@@ -25,7 +25,7 @@ module Xeroizer
 
       attr_reader :application
       attr_reader :model_name
-      attr :model_class
+      attr_writer :model_class
       attr_reader :response
 
       class << self
@@ -72,167 +72,182 @@ module Xeroizer
 
       public
 
-        def initialize(application, model_name)
-          @application = application
-          @model_name = model_name
-        end
+      def initialize(application, model_name)
+        @application = application
+        @model_name = model_name
+        @allow_batch_operations = false
+        @objects = {}
+      end
 
-        # Retrieve the controller name.
-        #
-        # Default: pluaralized model name (e.g. if the controller name is
-        # Invoice then the default is Invoices.
-        def api_controller_name
-          self.class.api_controller_name || model_name.pluralize
-        end
+      # Retrieve the controller name.
+      #
+      # Default: pluaralized model name (e.g. if the controller name is
+      # Invoice then the default is Invoices.
+      def api_controller_name
+        self.class.api_controller_name || model_name.pluralize
+      end
 
-        def model_class
-          @model_class ||= Xeroizer::Record.const_get(model_name.to_sym)
-        end
+      def model_class
+        @model_class ||= Xeroizer::Record.const_get(model_name.to_sym)
+      end
 
-        # Build a record with attributes set to the value of attributes.
-        def build(attributes = {})
-          model_class.build(attributes, self).tap do |resource|
-            mark_dirty(resource)
-          end
+      # Build a record with attributes set to the value of attributes.
+      def build(attributes = {})
+        model_class.build(attributes, self).tap do |resource|
+          mark_dirty(resource)
         end
+      end
 
-        def mark_dirty(resource)
-          if @allow_batch_operations
-            @objects[model_class] ||= {}
-            @objects[model_class][resource.object_id] ||= resource
-          end
+      def mark_dirty(resource)
+        if @allow_batch_operations
+          @objects[model_class] ||= {}
+          @objects[model_class][resource.object_id] ||= resource
         end
+      end
 
-        def mark_clean(resource)
-          if @objects and @objects[model_class]
-            @objects[model_class].delete(resource.object_id)
-          end
+      def mark_clean(resource)
+        if @objects and @objects[model_class]
+          @objects[model_class].delete(resource.object_id)
         end
+      end
 
-        # Create (build and save) a record with attributes set to the value of attributes.
-        def create(attributes = {})
-          build(attributes).tap { |resource| resource.save }
-        end
+      # Create (build and save) a record with attributes set to the value of attributes.
+      def create(attributes = {})
+        build(attributes).tap { |resource| resource.save }
+      end
 
-        # Retreive full record list for this model.
-        def all(options = {})
-          raise MethodNotAllowed.new(self, :all) unless self.class.permissions[:read]
-          response_xml = http_get(parse_params(options))
-          response = parse_response(response_xml, options)
-          response.response_items || []
-        end
+      # Retreive full record list for this model.
+      def all(options = {})
+        raise MethodNotAllowed.new(self, :all) unless self.class.permissions[:read]
+        response_xml = http_get(parse_params(options))
+        response = parse_response(response_xml, options)
+        response.response_items || []
+      end
 
-        # Helper method to retrieve just the first element from
-        # the full record list.
-        def first(options = {})
-          raise MethodNotAllowed.new(self, :all) unless self.class.permissions[:read]
-          result = all(options)
-          result.first if result.is_a?(Array)
+      # allow invoices to be process in batches of 100 as per xero documentation
+      # https://developer.xero.com/documentation/api/invoices/
+      def find_in_batches(options = {}, &block)
+        options[:page] ||= 1
+        while results = all(options)
+          if results.any?
+            yield results
+            options[:page] += 1
+          else
+            break
+          end
         end
+      end
 
-        # Retrieve record matching the passed in ID.
-        def find(id, options = {})
-          raise MethodNotAllowed.new(self, :all) unless self.class.permissions[:read]
-          response_xml = @application.http_get(@application.client, "#{url}/#{CGI.escape(id)}", options)
-          response = parse_response(response_xml, options)
-          result = response.response_items.first if response.response_items.is_a?(Array)
-          result.complete_record_downloaded = true if result
-          result
-        end
+      # Helper method to retrieve just the first element from
+      # the full record list.
+      def first(options = {})
+        raise MethodNotAllowed.new(self, :all) unless self.class.permissions[:read]
+        result = all(options)
+        result.first if result.is_a?(Array)
+      end
+
+      # Retrieve record matching the passed in ID.
+      def find(id, options = {})
+        raise MethodNotAllowed.new(self, :all) unless self.class.permissions[:read]
+        response_xml = @application.http_get(@application.client, "#{url}/#{CGI.escape(id)}", options)
+        response = parse_response(response_xml, options)
+        result = response.response_items.first if response.response_items.is_a?(Array)
+        result.complete_record_downloaded = true if result
+        result
+      end
 
-        def save_records(records, chunk_size = DEFAULT_RECORDS_PER_BATCH_SAVE)
-          no_errors = true
-          return false unless records.all?(&:valid?)
-
-          actions = records.group_by {|o| o.new_record? ? create_method : :http_post }
-          actions.each_pair do |http_method, records_for_method|
-            records_for_method.each_slice(chunk_size) do |some_records|
-              request = to_bulk_xml(some_records)
-              response = parse_response(self.send(http_method, request, {:summarizeErrors => false}))
-              response.response_items.each_with_index do |record, i|
-                if record and record.is_a?(model_class)
-                  some_records[i].attributes = record.non_calculated_attributes
-                  some_records[i].errors = record.errors
-                  no_errors = record.errors.nil? || record.errors.empty? if no_errors
-                  some_records[i].saved!
-                end
+      def save_records(records, chunk_size = DEFAULT_RECORDS_PER_BATCH_SAVE)
+        no_errors = true
+        return false unless records.all?(&:valid?)
+
+        actions = records.group_by {|o| o.new_record? ? create_method : :http_post }
+        actions.each_pair do |http_method, records_for_method|
+          records_for_method.each_slice(chunk_size) do |some_records|
+            request = to_bulk_xml(some_records)
+            response = parse_response(self.send(http_method, request, {:summarizeErrors => false}))
+            response.response_items.each_with_index do |record, i|
+              if record and record.is_a?(model_class)
+                some_records[i].attributes = record.non_calculated_attributes
+                some_records[i].errors = record.errors
+                no_errors = record.errors.nil? || record.errors.empty? if no_errors
+                some_records[i].saved!
               end
             end
           end
-
-          no_errors
         end
 
-        def batch_save(chunk_size = DEFAULT_RECORDS_PER_BATCH_SAVE)
-          @objects = {}
-          @allow_batch_operations = true
+        no_errors
+      end
 
-          begin
-            yield
+      def batch_save(chunk_size = DEFAULT_RECORDS_PER_BATCH_SAVE)
+        @objects = {}
+        @allow_batch_operations = true
 
-            if @objects[model_class]
-              objects = @objects[model_class].values.compact
-              save_records(objects, chunk_size)
-            end
-          ensure
-            @objects = {}
-            @allow_batch_operations = false
+        begin
+          yield
+
+          if @objects[model_class]
+            objects = @objects[model_class].values.compact
+            save_records(objects, chunk_size)
           end
+        ensure
+          @objects = {}
+          @allow_batch_operations = false
         end
+      end
 
-        def parse_response(response_xml, options = {})
-          Response.parse(response_xml, options) do | response, elements, response_model_name |
-            if model_name == response_model_name
-              @response = response
-              parse_records(response, elements, paged_records_requested?(options))
-            end
+      def parse_response(response_xml, options = {})
+        Response.parse(response_xml, options) do | response, elements, response_model_name |
+          if model_name == response_model_name
+            @response = response
+            parse_records(response, elements, paged_records_requested?(options), (options[:base_module] || Xeroizer::Record))
           end
         end
+      end
 
-        def create_method
-          :http_put
-        end
+      def create_method
+        :http_put
+      end
 
       protected
 
 
-        def paged_records_requested?(options)
-          options.has_key?(:page) and options[:page].to_i >= 0
-        end
-
+      def paged_records_requested?(options)
+        options.has_key?(:page) and options[:page].to_i >= 0
+      end
 
       # Parse the records part of the XML response and builds model instances as necessary.
-        def parse_records(response, elements, paged_results)
-          elements.each do | element |
-            new_record = model_class.build_from_node(element, self)
-            if element.attribute('status').try(:value) == 'ERROR'
-              new_record.errors = []
-              element.xpath('.//ValidationError').each do |err|
-                new_record.errors << err.text.gsub(/^\s+/, '').gsub(/\s+$/, '')
-              end
+      def parse_records(response, elements, paged_results, base_module)
+        elements.each do | element |
+          new_record = model_class.build_from_node(element, self, base_module)
+          if element.attribute('status').try(:value) == 'ERROR'
+            new_record.errors = []
+            element.xpath('.//ValidationError').each do |err|
+              new_record.errors << err.text.gsub(/^\s+/, '').gsub(/\s+$/, '')
             end
-            new_record.paged_record_downloaded = paged_results
-            response.response_items << new_record
           end
+          new_record.paged_record_downloaded = paged_results
+          response.response_items << new_record
         end
+      end
 
-        def to_bulk_xml(records, builder = Builder::XmlMarkup.new(:indent => 2))
-          tag = (self.class.optional_xml_root_name || model_name).pluralize
-          builder.tag!(tag) do
-            records.each {|r| r.to_xml(builder) }
-          end
+      def to_bulk_xml(records, builder = Builder::XmlMarkup.new(:indent => 2))
+        tag = (self.class.optional_xml_root_name || model_name).pluralize
+        builder.tag!(tag) do
+          records.each {|r| r.to_xml(builder) }
         end
+      end
 
-        # Parse the response from a create/update request.
-        def parse_save_response(response_xml)
-          response = parse_response(response_xml)
-          record = response.response_items.first if response.response_items.is_a?(Array)
-          if record && record.is_a?(self.class)
-            @attributes = record.attributes
-          end
-          self
+      # Parse the response from a create/update request.
+      def parse_save_response(response_xml)
+        response = parse_response(response_xml)
+        record = response.response_items.first if response.response_items.is_a?(Array)
+        if record && record.is_a?(self.class)
+          @attributes = record.attributes
         end
+        self
       end
+    end
 
   end
 end