xeroizer-float 2.15.3.1

data/lib/xeroizer/report/cell_xml_helper.rb

@@ -0,0 +1,74 @@
+module Xeroizer
+  module Report
+    module CellXmlHelper
+    
+      def self.included(base)
+        base.extend(ClassMethods)
+        base.send :include, InstanceMethods
+      end
+    
+      module ClassMethods
+      
+        public
+      
+          # Create an instance of Cell from the node.
+          #
+          # Additionally, parse the attributes and return them as a hash to the 
+          # cell. If a cell's attributes look like:
+          #
+          #     <Attributes>
+          #       <Attribute>
+          #         <Value>1335b8b2-4d63-4af8-937f-04087ae2e36e</Value>
+          #         <Id>account</Id>
+          #       </Attribute>
+          #     </Attributes>
+          # 
+          # Return a hash like:
+          #
+          #     {
+          #       'account' => '1335b8b2-4d63-4af8-937f-04087ae2e36e'
+          #     }
+          def build_from_node(node)
+            cell = new
+            node.elements.each do | element |
+              case element.name.to_s
+                when 'Value' then cell.value = parse_value(element.text)
+                when 'Attributes'
+                  element.elements.each do | attribute_node |
+                    (id, value) = parse_attribute(attribute_node)
+                    cell.attributes[id] = value
+                  end
+              end
+            end
+            cell
+          end
+          
+        protected
+
+          def parse_value(value)
+            case value
+              when /^[-]?\d+(\.\d+)?$/                      then BigDecimal.new(value)
+              when /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}$/  then Time.xmlschema(value)
+              else                                          value
+            end
+          end
+        
+          def parse_attribute(attribute_node)
+            id = nil
+            value = nil
+            attribute_node.elements.each do | element |
+              case element.name.to_s
+                when 'Id'     then id = element.text
+                when 'Value'  then value = element.text
+              end
+            end
+            [id, value]
+          end
+      end
+    
+      module InstanceMethods
+      end
+    
+    end
+  end
+end

data/lib/xeroizer/report/factory.rb

@@ -0,0 +1,53 @@
+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
+      
+      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 | response, elements |
+            parse_reports(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)
+          rescue NameError => ex # 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,55 @@
+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
+          
+          # 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/test/acceptance/about_creating_bank_transactions_test.rb

@@ -0,0 +1,162 @@
+require "test_helper"
+require "acceptance_test"
+
+class AboutCreatingBankTransactions < 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 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
+  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
+
+    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
+
+    expected_id = new_transaction.id
+
+    tax_rate = get_tax_rate(@account.tax_type).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
+
+  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
+    @all_tax_types ||= client.TaxRate.all
+    @all_tax_types.select{|tax_rate| tax_rate.tax_type == tax_type}.first
+  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
+  end
+
+  it "treats line item unit_amounts as tax EXCLUSIVE"
+  must "not set the tax_amount manually on line items"
+
+  def assert_exists(bank_transaction)
+    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
+
+  it "fails with RuntimeError when you try and create a new bank account" do
+    new_account = client.Account.build(
+      :name => "Example bank account",
+      :code => "ACC-001"
+    )
+
+    assert_raise RuntimeError do
+      new_account.save
+    end
+  end
+end