xeroizer 2.16.5 → 2.17.1

data/lib/xeroizer/record/base_model_http_proxy.rb

@@ -44,7 +44,7 @@ module Xeroizer
             conditions = []
             where.each do | key, value |
               (attribute_name, expression) = extract_expression_from_attribute_name(key)
-              (field_name, field) = model_class.fields.find { | k, v | v[:internal_name] == attribute_name }
+              (_, field) = model_class.fields.find { | k, v | v[:internal_name] == attribute_name }
               if field
                 conditions << where_condition_part(field, expression, value)                
               else

data/lib/xeroizer/record/payroll_base.rb

@@ -0,0 +1,25 @@
+module Xeroizer
+  module Record
+    
+    class PayrollBase < Xeroizer::Record::Base
+      
+      class_inheritable_attributes :fields, :possible_primary_keys, :primary_key_name, :summary_only, :validators
+
+      def self.belongs_to(field_name, options = {})
+        super(field_name, {:base_module => Xeroizer::Record::Payroll}.merge(options))
+      end
+
+      def self.has_many(field_name, options = {})
+        super(field_name, {:base_module => Xeroizer::Record::Payroll}.merge(options))
+      end
+      
+      public
+
+        def new_model_class(model_name)
+          Xeroizer::Record::Payroll.const_get("#{model_name}Model".to_sym).new(parent.application, model_name.to_s)
+        end
+
+    end
+
+  end
+end

data/lib/xeroizer/record/payroll_base_model.rb

@@ -0,0 +1,29 @@
+require 'xeroizer/record/base_model_http_proxy'
+
+module Xeroizer
+  module Record
+    
+    class PayrollBaseModel < Xeroizer::Record::BaseModel
+
+      class_inheritable_attributes :api_controller_name
+      class_inheritable_attributes :permissions
+      class_inheritable_attributes :xml_root_name
+      class_inheritable_attributes :optional_xml_root_name
+      class_inheritable_attributes :xml_node_name
+      
+      include BaseModelHttpProxy
+
+      public
+        
+        def model_class
+          @model_class ||= Xeroizer::Record::Payroll.const_get(model_name.to_sym)
+        end
+
+        def parse_response(response_xml, options = {})
+          super(response_xml, {:base_module => Xeroizer::Record::Payroll}.merge(options))
+        end
+
+    end
+
+  end
+end

data/lib/xeroizer/record/record_association_helper.rb

@@ -10,7 +10,7 @@ module Xeroizer
 
         def belongs_to(field_name, options = {})
           internal_field_name = options[:internal_name] || field_name
-          internal_singular_field_name = internal_field_name.to_s.singularize
+          internal_singular_field_name = options[:internal_name_singular] || internal_field_name.to_s.singularize
 
           define_association_attribute(field_name, internal_singular_field_name, :belongs_to, options)
 
@@ -25,7 +25,7 @@ module Xeroizer
             model_parent = new_model_class(model_name)
 
             # Create a new record, binding it to it's parent instance.
-            record = Xeroizer::Record.const_get(model_name).build(attributes, model_parent)
+            record = (options[:base_module] || Xeroizer::Record).const_get(model_name).build(attributes, model_parent)
             self.attributes[field_name] = record
           end
         end
@@ -34,8 +34,8 @@ module Xeroizer
 
         def has_many(field_name, options = {})
           internal_field_name = options[:internal_name] || field_name
-          internal_singular_field_name = internal_field_name.to_s.singularize
-
+          internal_singular_field_name = options[:internal_name_singular] || internal_field_name.to_s.singularize
+        
           define_association_attribute(field_name, internal_field_name, :has_many, options)
 
           # Create an #add_record_name method to build the record and add to the attributes.
@@ -47,7 +47,7 @@ module Xeroizer
             model_parent = new_model_class(model_name)
 
             # The class of this record.
-            record_class = Xeroizer::Record.const_get(model_name)
+            record_class = (options[:base_module] || Xeroizer::Record).const_get(model_name)
 
             # Parse the *args variable so that we can use this method like:
             #   add_record({fields}, {fields}, ...)
@@ -60,7 +60,7 @@ module Xeroizer
             elsif args.size > 0
               records = args
             else
-              raise StandardError.new("Invalid arguments for #{self.class.name}#add_#{internal_singular_field_name}(#{args.inspect}).")
+              raise XeroizerError.new("Invalid arguments for #{self.class.name}#add_#{internal_singular_field_name}(#{args.inspect}).")
             end
 
             # Ensure that complete record is downloaded before adding new records
@@ -70,7 +70,7 @@ module Xeroizer
             last_record = nil
             records.each do | record |
               record = record_class.build(record, model_parent) if record.is_a?(Hash)
-              raise StandardError.new("Record #{record.class.name} is not a #{record_class.name}.") unless record.is_a?(record_class)
+              raise XeroizerError.new("Record #{record.class.name} is not a #{record_class.name}.") unless record.is_a?(record_class)
               self.attributes[field_name] ||= []
               self.attributes[field_name] << record
               last_record = record
@@ -85,11 +85,10 @@ module Xeroizer
           define_simple_attribute(field_name, association_type, options.merge!(:skip_writer => true), ((association_type == :has_many) ? [] : nil))
 
           internal_field_name = options[:internal_name] || field_name
-          internal_singular_field_name = internal_field_name.to_s.singularize
+          internal_singular_field_name = options[:internal_name_singular] || internal_field_name.to_s.singularize
           model_name = options[:model_name] ? options[:model_name].to_sym : field_name.to_s.singularize.camelize.to_sym
-
-          define_method "#{internal_field_name}=".to_sym do | value |
-            record_class = Xeroizer::Record.const_get(model_name)
+          define_method "#{internal_field_name}=".to_sym do | value |    
+            record_class = (options[:base_module] || Xeroizer::Record).const_get(model_name)
             case value
               when Hash
                 self.attributes[field_name] = ((association_type == :has_many) ? [] : nil)
@@ -98,9 +97,9 @@ module Xeroizer
                     self.attributes[field_name] = []
                     self.send("add_#{internal_singular_field_name}".to_sym, value)
 
-                  when :belongs_to
-                    self.attributes[field_name] = Xeroizer::Record.const_get(model_name).build(value, new_model_class(model_name))
-
+                  when :belongs_to                  
+                    self.attributes[field_name] = (options[:base_module] || Xeroizer::Record).const_get(model_name).build(value, new_model_class(model_name))
+                   
                 end
 
               when Array

data/lib/xeroizer/record/validation_helper.rb

@@ -64,7 +64,7 @@ module Xeroizer
         
         def errors_for(attribute)
           if errors.is_a?(Array)
-            errors.find_all { | (attr, msg) | attr == attribute }.map { | (attr, msg) | msg }
+            errors.find_all { | (attr, _) | attr == attribute }.map { | (_, msg) | msg }
           end
         end
         

data/lib/xeroizer/record/xml_helper.rb

@@ -12,7 +12,7 @@ module Xeroizer
       module ClassMethods
         
         # Build a record instance from the XML node.
-        def build_from_node(node, parent)
+        def build_from_node(node, parent, base_module)
           record = new(parent)
           node.elements.each do | element |
             field = self.fields[element.name.to_s.underscore.to_sym]
@@ -25,17 +25,17 @@ module Xeroizer
                 when :decimal     then BigDecimal.new(element.text)
                 when :date        then Date.parse(element.text)
                 when :datetime    then Time.parse(element.text)
-                when :datetime_utc then ActiveSupport::TimeZone['UTC'].parse(element.text).utc.round(3)
+                when :datetime_utc then ActiveSupport::TimeZone['UTC'].parse(element.text).utc
                 when :belongs_to  
                   model_name = field[:model_name] ? field[:model_name].to_sym : element.name.to_sym
-                  Xeroizer::Record.const_get(model_name).build_from_node(element, parent)
+                  base_module.const_get(model_name).build_from_node(element, parent, base_module)
                   
                 when :has_many
                   if element.element_children.size > 0
                     sub_field_name = field[:model_name] ? field[:model_name].to_sym : element.children.first.name.to_sym
                     sub_parent = record.new_model_class(sub_field_name)
-                    element.children.inject([]) do | list, element |
-                      list << Xeroizer::Record.const_get(sub_field_name).build_from_node(element, sub_parent)
+                    element.children.inject([]) do | list, inner_element |
+                      list << base_module.const_get(sub_field_name).build_from_node(inner_element, sub_parent, base_module)
                     end
                   end
 
@@ -60,8 +60,8 @@ module Xeroizer
         
           # Turn a record into its XML representation.
           def to_xml(b = Builder::XmlMarkup.new(:indent => 2))
-            optional_root_tag(parent.class.optional_xml_root_name, b) do |b|
-              b.tag!(model.class.xml_node_name || model.model_name) {
+            optional_root_tag(parent.class.optional_xml_root_name, b) do |c|
+              c.tag!(model.class.xml_node_name || model.model_name) {
                 attributes.each do | key, value |
                   field = self.class.fields[key]
                   value = self.send(key) if field[:calculated]
@@ -82,7 +82,7 @@ module Xeroizer
           #   </Payments>
           def optional_root_tag(root_name, b, &block)
             if root_name
-              b.tag!(root_name) { |b| yield(b) }
+              b.tag!(root_name) { |c| yield(c) }
             else
               yield(b)
             end
@@ -107,6 +107,8 @@ module Xeroizer
                 real_value = case value
                   when Date         then value.strftime("%Y-%m-%d")
                   when Time         then value.utc.strftime("%Y-%m-%d")
+                  when NilClass     then nil
+                  else raise ArgumentError.new("Expected Date or Time object for the #{field[:api_name]} field")
                 end
                 b.tag!(field[:api_name], real_value)
                 

data/lib/xeroizer/report/aged_receivables_by_contact.rb

@@ -32,7 +32,6 @@ module Xeroizer
 
         def sum(column_name, &block)
           sections.first.rows.inject(BigDecimal.new('0')) do | sum, row |
-            cell = row.cell(column_name)
             sum += row.cell(column_name).value if row.class == Xeroizer::Report::Row && (block.nil? || block.call(row))
             sum
           end

data/lib/xeroizer/report/base.rb

@@ -1,4 +1,3 @@
-require 'xeroizer/report/base'
 require 'xeroizer/report/cell'
 require 'xeroizer/report/row/row'
 require 'xeroizer/report/row/header'

data/lib/xeroizer/report/factory.rb

@@ -23,8 +23,8 @@ module Xeroizer
         # valid query-string parameters to pass to the API.
         def get(options = {})
           @response_xml = options[:cache_file] ? File.read(options[:cache_file]) : http_get(options)
-          response = Response.parse(response_xml, options) do | response, elements |
-            parse_reports(response, elements)
+          response = Response.parse(response_xml, options) do | inner_response, elements |
+            parse_reports(inner_response, elements)
           end
           response.response_items.first # there is is only one
         end
@@ -36,7 +36,7 @@ module Xeroizer
         def klass
           begin
             @_klass_cache ||= Xeroizer::Report.const_get(report_type, false)
-          rescue NameError => ex # use default class
+          rescue NameError # use default class
             Base
           end
         end

data/lib/xeroizer/report/row/header.rb

@@ -2,10 +2,10 @@ module Xeroizer
   module Report
     class HeaderRow < Row
 
-        def column_index(column_name)
-          @_column_index_cache ||= {}
-          @_column_index_cache[column_name] ||= cells.find_index { | cell | cell.value == column_name.to_s }
-        end
+      def column_index(column_name)
+        @_column_index_cache ||= {}
+        @_column_index_cache[column_name] ||= cells.find_index { | cell | cell.value == column_name.to_s }
+      end
         
     end
   end

data/lib/xeroizer/report/row/xml_helper.rb

@@ -16,7 +16,7 @@ module Xeroizer
             row = nil
             case row_type
               when 'Header'
-                row = HeaderRow.new(report);
+                row = HeaderRow.new(report)
                 parent.header = row if parent
                 report.header ||= row
                 
@@ -26,7 +26,7 @@ module Xeroizer
                 report.sections << row
                 
               when 'SummaryRow'
-                row = SummaryRow.new(report);
+                row = SummaryRow.new(report)
                 row.header = report.header
                 if parent
                   parent.summary = row

data/lib/xeroizer/version.rb

@@ -1,3 +1,3 @@
 module Xeroizer
-  VERSION = "2.16.5".freeze
+  VERSION = "2.17.1".freeze
 end

data/test/acceptance/about_creating_prepayment_test.rb

@@ -0,0 +1,46 @@
+require "test_helper"
+require "acceptance_test"
+
+class AboutCreatingPrepayment < Test::Unit::TestCase
+  include AcceptanceTest
+
+  let :client do
+    Xeroizer::PrivateApplication.new(@consumer_key, @consumer_secret, @key_file)
+  end
+
+  def setup
+    super
+    all_accounts = client.Account.all
+    @account = all_accounts.select{|acct| acct.status == "ACTIVE" && acct.type == "REVENUE"}.first
+    @bank_account = all_accounts.select{|acct| acct.status == "ACTIVE" && acct.type == "BANK"}.first    
+  end
+
+  can "create a new PrePayment bank transaction" do
+    new_transaction = client.BankTransaction.build(
+      :type => "RECEIVE-PREPAYMENT",
+      :contact => { :name => "Jazz Kang" },
+      :line_items => any_line_items(@account),
+      :bank_account => { :account_id => @bank_account.account_id }
+    )
+
+    assert new_transaction.save, "Save failed with the following errors: #{new_transaction.errors.inspect}"
+    assert_exists new_transaction
+  end
+
+  def any_line_items(account)
+    [{
+      :description => "Clingfilm bike shorts",
+      :quantity => 1,
+      :unit_amount => "200.00",
+      :account_code => account.code,
+      :tax_type => account.tax_type
+    }]
+  end
+
+  def assert_exists(prepayment)
+    assert_not_nil prepayment.id,
+      "Cannot check for exitence unless the prepayment (bank transaction) has non-null identifier"
+    assert_not_nil client.BankTransaction.find prepayment.id
+  end
+
+end

data/test/acceptance/about_fetching_bank_transactions_test.rb

@@ -9,6 +9,26 @@ class AboutFetchingBankTransactions < Test::Unit::TestCase
     @client ||= Xeroizer::PrivateApplication.new(@consumer_key, @consumer_secret, @key_file)
   end
 
+  context "when requesting a single bank transaction with a reference" do
+    setup do
+      @a_new_bank_transaction = BankTransactionReferenceData.new(client).bank_transaction
+    end
+
+    it "has the extended set of attributes" do
+      keys = [:line_amount_types, :contact, :date, :status, :line_items,
+              :updated_date_utc, :currency_code, :bank_transaction_id,
+              :bank_account, :type, :reference, :is_reconciled, :currency_rate]
+      assert_equal(@a_new_bank_transaction.attributes.keys, keys)
+    end
+
+    it "returns full line item details" do
+      single_bank_transaction = client.BankTransaction.find @a_new_bank_transaction.id
+
+      assert_not_empty single_bank_transaction.line_items,
+        "expected the bank transaction's line items to have been included"
+    end
+  end
+
   context "when requesting all bank transactions (i.e., without filter)" do
     setup do
       @the_first_bank_transaction = client.BankTransaction.all.first
@@ -16,7 +36,7 @@ class AboutFetchingBankTransactions < Test::Unit::TestCase
 
     it "has the limited set of attributes" do
       keys = [:line_amount_types, :contact, :date, :status, :updated_date_utc, 
-              :currency_code, :bank_transaction_id, :bank_account, :type, 
+              :currency_code, :bank_transaction_id, :bank_account, :type, :reference, 
               :is_reconciled]
       assert_equal(@the_first_bank_transaction.attributes.keys, keys)
     end
@@ -29,25 +49,5 @@ class AboutFetchingBankTransactions < Test::Unit::TestCase
       assert_not_nil @the_first_bank_transaction.bank_account
     end
   end
-
-  context "when requesting a single bank transaction for example" do
-    setup do
-      @a_new_bank_transaction = BankTransactionReferenceData.new(client).bank_transaction
-    end
-
-    it "has the extended set of attributes" do
-      keys = [:line_amount_types, :contact, :date, :status, :line_items,
-              :updated_date_utc, :currency_code, :bank_transaction_id,
-              :bank_account, :type, :is_reconciled, :currency_rate]
-      assert_equal(@a_new_bank_transaction.attributes.keys, keys)
-    end
-
-    it "returns full line item details" do
-      single_bank_transaction = client.BankTransaction.find @a_new_bank_transaction.id
-
-      assert_not_empty single_bank_transaction.line_items,
-        "expected the bank transaction's line items to have been included"
-    end
-  end
 end
 

data/test/acceptance/acceptance_test.rb

@@ -38,7 +38,7 @@ module AcceptanceTest
   def load_config_from_file
     the_file_name = File.join(File.dirname(__FILE__), '..', '..', '.oauth')
 
-    return nil unless File.exists? the_file_name
+    return nil unless File.exist? the_file_name
 
     Xeroizer::OAuthConfig.load IO.read the_file_name
   end
@@ -46,8 +46,8 @@ module AcceptanceTest
   def load_config_from_env
     assert_not_nil ENV["CONSUMER_KEY"], "No CONSUMER_KEY environment variable specified."
     assert_not_nil ENV["CONSUMER_SECRET"], "No CONSUMER_SECRET environment variable specified."
-    assert_not_nil ENV["KEY_FILE"], "No KEY_FILE environment variable specified."
-    assert File.exists?(ENV["KEY_FILE"]), "The file <#{ENV["KEY_FILE"]}> does not exist."
-    Xeroizer::OAuthCredentials.new ENV["CONSUMER_KEY"], ENV["CONSUMER_SECRET"], ENV["KEY_FILE"]
+    assert_not_nil ENV["PRIVATE_KEY_PATH"], "No PRIVATE_KEY_PATH environment variable specified."
+    assert File.exist?(ENV["PRIVATE_KEY_PATH"]), "The file <#{ENV["PRIVATE_KEY_PATH"]}> does not exist."
+    Xeroizer::OAuthCredentials.new ENV["CONSUMER_KEY"], ENV["CONSUMER_SECRET"], ENV["PRIVATE_KEY_PATH"]
   end
 end

data/test/acceptance/bank_transaction_reference_data.rb

@@ -20,11 +20,13 @@ class BankTransactionReferenceData
         :account_code => account.code,
         :tax_type => account.tax_type
       ],
-      :bank_account => { :account_id => bank_account.account_id }
+      :bank_account => { :account_id => bank_account.account_id },
+      :reference => "BTF323"
     )
 
     fail("Expected save to have succeeded, but it failed. #{result.errors.inspect}") unless result.save
 
     result
   end
+
 end

data/test/acceptance/bank_transfer_test.rb

@@ -0,0 +1,26 @@
+require "test_helper"
+require "acceptance_test"
+
+class BankTransfer < Test::Unit::TestCase
+  include AcceptanceTest
+
+  let :client do
+    Xeroizer::PrivateApplication.new(@consumer_key, @consumer_secret, @key_file)
+  end
+
+  def setup
+    super
+    all_accounts = client.Account.all
+    @from_bank_account = all_accounts.select { |acct| acct.status == "ACTIVE" && acct.type == "BANK" }.first
+    @to_bank_account = all_accounts.select { |acct| acct.status == "ACTIVE" && acct.type == "BANK" }.last
+  end
+
+  can "create a bank transfer" do
+    new_transfer = client.BankTransfer.build(
+      :amount => 300,
+      :from_bank_account => { :account_id => @from_bank_account.account_id },
+      :to_bank_account => { :account_id => @to_bank_account.account_id }
+    )
+    assert new_transfer.save, "Save failed with the following errors: #{new_transfer.errors.inspect}"
+  end
+end