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

data/lib/xeroizer/report/factory.rb

@@ -0,0 +1,54 @@
+require 'xeroizer/application_http_proxy' 
+require 'xeroizer/report/base'
+require 'xeroizer/report/aged_receivables_by_contact'
+
+module Xeroizer
+  module Report
+    class Factory
+      
+      include ApplicationHttpProxy
+
+      attr_reader :application
+      attr_reader :report_type
+      attr_reader :response_xml
+      
+      public
+      
+        def initialize(application, report_type)
+          @application = application
+          @report_type = report_type
+        end
+      
+        # Retreive a report with the `options` as a hash containing
+        # 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 | inner_response, elements |
+            parse_reports(inner_response, elements)
+          end
+          response.response_items.first # there is is only one
+        end
+      
+        def api_controller_name
+          "Reports/#{report_type}"
+        end
+
+        def klass
+          begin
+            @_klass_cache ||= Xeroizer::Report.const_get(report_type, false)
+          rescue NameError # use default class
+            Base
+          end
+        end
+
+      protected
+              
+        def parse_reports(response, elements)
+          elements.each do | element |
+            response.response_items << klass.build_from_node(element, self)
+          end
+        end
+        
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+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
+        
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+require 'xeroizer/report/row/xml_helper'
+
+module Xeroizer
+  module Report
+    class Row
+      
+      include RowXmlHelper
+      
+      attr_reader :report
+      
+      attr_accessor :type
+      attr_accessor :title
+      attr_accessor :rows
+      attr_accessor :cells
+      
+      attr_accessor :parent
+      
+      attr_accessor :header
+      
+      public
+      
+        def initialize(report)
+          @rows = []
+          @cells = []
+          @report = report
+        end
+        
+        def header?;  @type == 'Header';      end
+        def summary?; @type == 'SummaryRow';  end
+        def section?; @type == 'Section';     end
+        def row?;     @type == 'Row';         end
+           
+        def child?
+          !parent.nil?
+        end
+        
+        def parent?
+          rows.size > 0
+        end
+
+        def cell(column_name)
+          index = header.column_index(column_name)
+          cells[index] if index >= 0
+        end
+
+    end
+  end
+end

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

@@ -0,0 +1,10 @@
+module Xeroizer
+  module Report
+    class SectionRow < Row
+      
+      attr_accessor :header
+      attr_accessor :summary
+      
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+module Xeroizer
+  module Report
+    class SummaryRow < Row
+   
+      attr_accessor :header
+      
+    end
+  end
+end

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

@@ -0,0 +1,77 @@
+module Xeroizer
+  module Report
+    module RowXmlHelper
+    
+      def self.included(base)
+        base.extend(ClassMethods)
+        base.send :include, InstanceMethods
+      end
+    
+      module ClassMethods
+      
+        public
+      
+          def build_from_node(node, report, parent = nil)
+            row_type = node.xpath('RowType').first.text
+            row = nil
+            case row_type
+              when 'Header'
+                row = HeaderRow.new(report)
+                parent.header = row if parent
+                report.header ||= row
+                
+              when 'Section'
+                row = SectionRow.new(report)
+                row.header = report.header
+                report.sections << row
+                
+              when 'SummaryRow'
+                row = SummaryRow.new(report)
+                row.header = report.header
+                if parent
+                  parent.summary = row
+                  
+                  # Also add this summary row to the report if the section
+                  # title is blank and the report doesn't already have one.
+                  if parent.title.to_s == '' && report.summary.nil?
+                    report.summary = row
+                  end
+                else
+                  report.summary = row
+                end
+                
+              else
+                row = Row.new(report)
+                row.header = report.header
+                
+            end
+            row.parent = parent
+            
+            node.elements.each do | element |
+              case element.name.to_s
+                when 'RowType'  then row.type = element.text
+                when 'Title'    then row.title = element.text
+                when 'Rows'
+                  element.elements.each do | row_node |
+                    row.rows << Row.build_from_node(row_node, report, row)
+                  end
+                  
+                when 'Cells'
+                  element.elements.each do | cell_node |
+                    row.cells << Cell.build_from_node(cell_node)
+                  end
+                  
+              end
+            end
+                        
+            row
+          end
+                  
+      end
+    
+      module InstanceMethods
+      end
+    
+    end
+  end
+end

data/lib/xeroizer/report/xml_helper.rb

@@ -0,0 +1,58 @@
+module Xeroizer
+  module Report
+    module XmlHelper
+      
+      def self.included(base)
+        base.extend(ClassMethods)
+        base.send :include, InstanceMethods
+      end
+      
+      module ClassMethods
+        
+        public
+        
+          def build_from_node(node, factory)
+            report = new(factory)
+            
+            extract_report_details(report, node)
+            
+            rows = node.xpath("Rows/Row")
+            extract_rows(report, rows) if rows && rows.size > 0
+            
+            report
+          end
+
+        protected
+        
+          # Extract header details for the report response.
+          def extract_report_details(report, node)
+            node.elements.each do | element |
+              case element.name.to_s
+                when 'ReportID'       then report.id = element.text
+                when 'ReportName'     then report.name = element.text
+                when 'ReportType'     then report.type = element.text
+                when 'ReportDate'     then report.date = Date.parse(element.text)
+                when 'UpdatedDateUTC' then report.updated_at = Time.parse(element.text)
+                when 'ReportTitles'
+                  element.elements.each do | title_element |
+                    report.titles << title_element.text
+                  end
+              end
+            end
+          end
+          
+          # Extract the report rows
+          def extract_rows(report, rows)
+            rows.each do | row_node |
+              report.rows << Row.build_from_node(row_node, report)
+            end
+          end
+          
+      end
+      
+      module InstanceMethods
+      end
+      
+    end
+  end
+end

data/lib/xeroizer/response.rb

@@ -0,0 +1,74 @@
+# Copyright (c) 2008 Tim Connor <tlconnor@gmail.com>
+#
+# Permission to use, copy, modify, and/or distribute this software for any
+# purpose with or without fee is hereby granted, provided that the above
+# copyright notice and this permission notice appear in all copies.
+#
+# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+# OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+module Xeroizer
+  class Response
+
+    attr_accessor :id, :status, :errors, :provider, :date_time, :response_items, :request_params, :request_xml, :response_xml
+
+    class << self
+
+      # Parse the response retreived during any request.
+      def parse(raw_response, request = {}, options = {}, &block)
+        response = Xeroizer::Response.new
+        response.response_xml = raw_response
+
+        doc = Nokogiri::XML(raw_response) { | cfg | cfg.noblanks }
+
+        # check for responses we don't understand
+        raise Xeroizer::UnparseableResponse.new(doc.root.name) unless doc.root.name == 'Response'
+
+        doc.root.elements.each do | element |
+
+          # Text element
+          if element.children && element.children.size == 1 && element.children.first.text?
+            case element.name
+              when 'Id'           then response.id = element.text
+              when 'Status'       then response.status = element.text
+              when 'ProviderName' then response.provider = element.text
+              when 'DateTimeUTC'  then response.date_time = Time.parse(element.text)
+            end
+
+          # Special case for Paystubs and PayItems because they are not wrapped in plural element or
+          # don't have singular children
+          elsif element.children && element.children.size > 0 && (element.name == 'Paystub' || element.name == 'PayItems')
+            yield(response, [element], element.name)
+
+          # Records in response
+          elsif element.children && element.children.size > 0
+            yield(response, element.children, element.children.first.name)
+          end
+        end
+
+        response
+      end
+
+    end
+
+    public
+
+      def initialize
+        @response_items = []
+      end
+
+      def success?
+        status == 'OK'
+      end
+
+      def error
+        errors.blank? ? nil : errors[0]
+      end
+
+  end
+end

data/lib/xeroizer/version.rb

@@ -0,0 +1,3 @@
+module Xeroizer
+  VERSION = "3.0.0-beta".freeze
+end

data/test/acceptance/about_creating_bank_transactions_test.rb

@@ -0,0 +1,170 @@
+require "test_helper"
+require "acceptance_test"
+
+class AboutCreatingBankTransactions < Test::Unit::TestCase
+  include AcceptanceTest
+
+  def assert_exists(bank_transaction, client)
+    assert_not_nil bank_transaction.id,
+                   "Cannot check for exitence unless the bank transaction has non-null identifier"
+    assert_not_nil client.BankTransaction.find bank_transaction.id
+  end
+
+  def any_line_items(account)
+    [{
+         :description => "Clingfilm bike shorts",
+         :quantity => 1,
+         :unit_amount => "17.00",
+         :account_code => account.code,
+         :tax_type => account.tax_type
+     }]
+  end
+
+  def get_inclusive_tax(amount, tax_rate)
+    inclusive_tax = amount * (1 - (100/(100 + tax_rate)))
+    BigDecimal(inclusive_tax.to_s).round(2)
+  end
+
+  def get_exclusive_tax(amount, tax_rate)
+    exclusive_tax = amount * (tax_rate/100)
+    BigDecimal(exclusive_tax.to_s).round(2)
+  end
+
+  def get_tax_rate(tax_type, client)
+    @all_tax_types ||= client.TaxRate.all
+    @all_tax_types.select{|tax_rate| tax_rate.tax_type == tax_type}.first
+  end
+
+  setup do
+    @client = AcceptanceTestHelpers.oauth2_client
+    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 SPEND bank transaction" do
+    new_transaction = @client.BankTransaction.build(
+        :type => "SPEND",
+        :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, @client)
+  end
+
+  can "update a SPEND bank transaction, for example by setting its status" do
+    new_transaction = @client.BankTransaction.build(
+        :type => "SPEND",
+        :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, @client
+
+    the_new_type = "RECEIVE"
+
+    expected_id = new_transaction.id
+
+    new_transaction.type = the_new_type
+
+    assert new_transaction.save, "Update failed with the following errors: #{new_transaction.errors.inspect}"
+
+    assert_equal expected_id, new_transaction.id, "Expected the id to be the same because it has been updated"
+
+    refreshed_bank_transaction = @client.BankTransaction.find expected_id
+
+    assert_equal the_new_type, refreshed_bank_transaction.type,
+                 "Expected the bank transaction to've had its type updated"
+  end
+
+  can "update a bank transaction by adding line items provided you calculate the tax_amount correctly" do
+    new_transaction = @client.BankTransaction.build(
+        :type => "SPEND",
+        :contact => { :name => "Jazz Kang" },
+        :line_items => any_line_items(@account),
+        :bank_account => { :account_id => @bank_account.account_id },
+        :line_amount_types => "Exclusive"
+    )
+
+    assert new_transaction.save, "Save failed with the following errors: #{new_transaction.errors.inspect}"
+    assert_exists new_transaction, @client
+
+    expected_id = new_transaction.id
+
+    tax_rate = get_tax_rate(@account.tax_type, @client).effective_rate
+
+    unit_price = BigDecimal("1337.00")
+
+    the_new_line_items = [
+        {
+            :description => "Burrito skin",
+            :quantity => 1,
+            :unit_amount => unit_price,
+            :account_code => @account.code,
+            :tax_type => @account.tax_type,
+            :tax_amount => get_exclusive_tax(unit_price, tax_rate)
+        }
+    ]
+
+    new_transaction.line_items = the_new_line_items
+
+    assert new_transaction.save, "Update failed with the following errors: #{new_transaction.errors.inspect}"
+
+    refreshed_bank_transaction = @client.BankTransaction.find expected_id
+
+    assert_equal expected_id, new_transaction.id,
+                 "Expected the id to be the same because it has been updated"
+
+    assert_equal 1, refreshed_bank_transaction.line_items.size,
+                 "Expected the bank transaction to've had its line items updated to just one"
+
+    the_first_line_item = refreshed_bank_transaction.line_items.first
+
+    assert_equal "Burrito skin", the_first_line_item.description,
+                 "Expected the bank transaction to've had its line items updated, " +
+                     "but the first one's description does not match: #{the_first_line_item.inspect}"
+  end
+
+  can "create a new RECEIVE bank transaction" do
+    new_transaction = @client.BankTransaction.build(
+        :type => "RECEIVE",
+        :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, @client
+  end
+
+  it "treats line item unit_amounts as tax EXCLUSIVE"
+  must "not set the tax_amount manually on line items"
+
+
+
+  it "fails with ApiException when you try and create a new bank account with missing account type with save! method" do
+    new_account = @client.Account.build(
+        :name => "Example bank account",
+        :code => "ACC-001"
+    )
+
+    assert_raise Xeroizer::ApiException do
+      new_account.save!
+    end
+  end
+
+  it "returns false when you try and create a new bank account with a missing account type with save method" do
+    new_account = @client.Account.build(
+        :name => "Example bank account",
+        :code => "ACC-001"
+    )
+
+    assert new_account.save == false, "Account save method expected to return false"
+
+  end
+end