xeroizer-float 2.15.3.1

data/lib/xeroizer/record/validation_helper.rb

@@ -0,0 +1,71 @@
+Dir.foreach(File.join(File.dirname(__FILE__), 'validators/')) { | file | require File.join(File.dirname(__FILE__), "validators/#{file}") if file =~ /\.rb$/ }
+
+module Xeroizer
+  module Record
+    module ValidationHelper
+      
+      def self.included(base)
+        base.extend(ClassMethods)
+        base.send :include, InstanceMethods
+      end
+      
+      module ClassMethods
+        
+        # Adds a validator config for each attribute specified in args.
+        def validates_with_validator(validator, args)
+          options = args.extract_options!
+          
+          self.validators ||= []
+          args.flatten.each do | attribute |
+            self.validators << validator.new(attribute, options)
+          end
+        end
+        
+        def validates_associated(*args)
+          validates_with_validator(Validator::AssociatedValidator, args)
+        end
+        
+        def validates_inclusion_of(*args)
+          validates_with_validator(Validator::InclusionOfValidator, args)
+        end
+
+        def validates_presence_of(*args)
+          validates_with_validator(Validator::PresenceOfValidator, args)
+        end        
+     
+        def validates(*args, &block)
+          fail "Block required" unless block_given?
+
+          if args.last.is_a? Hash
+            args.last[:block] = block
+          else
+            args << { :block => block }
+          end
+
+          validates_with_validator(Validator::BlockValidator, args)
+        end
+      end
+      
+      module InstanceMethods
+      
+        def valid?
+          @errors = []
+          if self.class.validators
+            self.class.validators.each do | validator |
+              validator.validate(self)
+            end
+          end
+          @errors.size == 0
+        end
+        
+        def errors_for(attribute)
+          if errors.is_a?(Array)
+            errors.find_all { | (attr, msg) | attr == attribute }.map { | (attr, msg) | msg }
+          end
+        end
+        
+      end
+      
+    end
+  end
+end

data/lib/xeroizer/record/validators/associated_validator.rb

@@ -0,0 +1,33 @@
+module Xeroizer
+  module Record
+    
+    class Validator
+  
+      class AssociatedValidator < Validator
+        
+        def valid?(record)
+          case record.class.fields[attribute][:type]
+            when :belongs_to
+              return true if options[:allow_blanks] && record[attribute].nil?
+              unless record[attribute].is_a?(Xeroizer::Record::Base) && record[attribute].valid?
+                record.errors << [attribute, options[:message] || "must be valid"]
+              end
+              
+            when :has_many
+              return true if options[:allow_blanks] && (record[attribute].nil? || (record[attribute].is_a?(Array) && record[attribute].size == 0))
+              if record[attribute].is_a?(Array) && record[attribute].size > 0
+                unless record[attribute].all? { | r | r.is_a?(Xeroizer::Record::Base) && r.valid? }
+                  record.errors << [attribute, options[:message] || "must all be valid"]
+                end
+              else
+                record.errors << [attribute, "must have one or more records"] 
+              end
+          end
+        end
+        
+      end
+  
+    end
+    
+  end
+end

data/lib/xeroizer/record/validators/block_validator.rb

@@ -0,0 +1,22 @@
+module Xeroizer
+  module Record
+    class Validator
+      class BlockValidator < Validator
+        def valid?(record)
+          fail "No block provided" unless options[:block]
+          
+          result = record.instance_eval &options[:block]
+          
+          record.errors << [attribute, message] unless result == true
+        end
+
+        private
+        
+        def message
+          supplied_message = options[:message] || ""
+          supplied_message.empty? ? "block condition failed" : supplied_message
+        end
+      end
+    end
+  end
+end

data/lib/xeroizer/record/validators/inclusion_of_validator.rb

@@ -0,0 +1,22 @@
+module Xeroizer
+  module Record
+    
+    class Validator
+  
+      class InclusionOfValidator < Validator
+        
+        def valid?(record)
+          if options[:in] && options[:in].is_a?(Array)            
+            return true if options[:allow_blanks] && (record[attribute].nil? || record[attribute].to_s == '')
+            unless options[:in].include?(record[attribute])
+              record.errors << [attribute, options[:message] || "not one of #{options[:in].join(', ')}"]
+            end
+          end
+        end
+        
+      end
+  
+    end
+    
+  end
+end

data/lib/xeroizer/record/validators/presence_of_validator.rb

@@ -0,0 +1,19 @@
+module Xeroizer
+  module Record
+    
+    class Validator
+  
+      class PresenceOfValidator < Validator
+        
+        def valid?(record)
+          if record[attribute].nil? || record[attribute].to_s == ''
+            record.errors << [attribute, options[:message] || "can't be blank"]
+          end
+        end
+        
+      end
+  
+    end
+    
+  end
+end

data/lib/xeroizer/record/validators/validator.rb

@@ -0,0 +1,33 @@
+module Xeroizer
+  module Record
+    
+    class Validator
+      
+      attr_reader :attribute
+      attr_reader :options
+      
+      def initialize(attribute, options = {})
+        @attribute = attribute
+        @options = options
+      end
+  
+      def validate(record)
+        valid?(record) if run_validator?(record, options)
+      end
+
+      def run_validator?(record, options)
+        return false if options[:if] && !condition?(record, options[:if])
+        return false if options[:unless] && condition?(record, options[:unless])
+        true
+      end
+
+      def condition?(record, condition)
+        return condition.call(record) if condition.respond_to? :call
+        return record.send(condition) if condition.is_a? Symbol
+        raise "Validation condition must be a Symbol or an Object that responds to call"
+      end
+
+    end
+    
+  end
+end

data/lib/xeroizer/record/xml_helper.rb

@@ -0,0 +1,133 @@
+require 'active_support/time'
+
+module Xeroizer
+  module Record
+    module XmlHelper
+      
+      def self.included(base)
+        base.extend(ClassMethods)
+        base.send :include, InstanceMethods
+      end
+      
+      module ClassMethods
+        
+        # Build a record instance from the XML node.
+        def build_from_node(node, parent)
+          record = new(parent)
+          node.elements.each do | element |
+            field = self.fields[element.name.to_s.underscore.to_sym]
+            if field
+              value = case field[:type]
+                when :guid        then element.text
+                when :string      then element.text
+                when :boolean     then (element.text == 'true')
+                when :integer     then element.text.to_i
+                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)
+                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)
+                  
+                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)
+                    end
+                  end
+
+              end
+              if field[:calculated]
+                record.attributes[field[:internal_name]] = value
+              else
+                record.send("#{field[:internal_name]}=".to_sym, value)
+              end
+            end
+          end
+          
+          record
+        end
+        
+      end
+      
+      module InstanceMethods
+        
+        public
+        
+          # 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!(parent.class.xml_node_name || parent.model_name) { 
+                attributes.each do | key, value |
+                  field = self.class.fields[key]
+                  value = self.send(key) if field[:calculated]
+                  xml_value_from_field(b, field, value) unless value.nil?
+                end
+              }
+            end
+          end
+          
+        protected
+        
+          # Add top-level root name if required.
+          # E.g. Payments need specifying in the form:
+          #   <Payments>
+          #     <Payment>
+          #       ...
+          #     </Payment>
+          #   </Payments>
+          def optional_root_tag(root_name, b, &block)
+            if root_name
+              b.tag!(root_name) { |b| yield(b) }
+            else
+              yield(b)
+            end
+          end
+        
+          # Format a attribute for use in the XML passed to Xero.
+          def xml_value_from_field(b, field, value)
+            case field[:type]
+              when :guid        then b.tag!(field[:api_name], value)
+              when :string      then b.tag!(field[:api_name], value)
+              when :boolean     then b.tag!(field[:api_name], value ? 'true' : 'false')
+              when :integer     then b.tag!(field[:api_name], value.to_i)
+              when :decimal   
+                real_value = case value
+                  when BigDecimal   then value.to_s
+                  when String       then BigDecimal.new(value).to_s
+                  else              value
+                end
+                b.tag!(field[:api_name], real_value)
+
+              when :date
+                real_value = case value
+                  when Date         then value.strftime("%Y-%m-%d")
+                  when Time         then value.utc.strftime("%Y-%m-%d")
+                end
+                b.tag!(field[:api_name], real_value)
+                
+              when :datetime    then b.tag!(field[:api_name], value.utc.strftime("%Y-%m-%dT%H:%M:%S"))
+              when :belongs_to  
+                value.to_xml(b)
+                nil
+
+              when :has_many    
+                if value.size > 0
+                  sub_parent = value.first.parent
+                  b.tag!(sub_parent.class.xml_root_name || sub_parent.model_name.pluralize) {
+                    value.each { | record | record.to_xml(b) }
+                  }
+                  nil
+                end
+
+            end
+          end
+        
+      end
+      
+    end
+  end
+end

data/lib/xeroizer/report/aged_receivables_by_contact.rb

@@ -0,0 +1,43 @@
+module Xeroizer
+  module Report
+    class AgedReceivablesByContact < Base
+
+      public
+
+        def total
+          @_total_cache ||= summary.cell(:Total).value 
+        end
+
+        def total_paid
+          @_total_paid_cache ||= summary.cell(:Paid).value
+        end
+
+        def total_credited
+          @_total_credited_cache ||= summary.cell(:Credited).value
+        end
+
+        def total_due
+          @_total_due_cache ||= summary.cell(:Due).value
+        end
+
+        def total_overdue
+          return @_total_due_cache if @_total_due_cache
+          
+          now = Time.now
+          @_total_due_cache = sum(:Due) do | row | 
+            due_date = row.cell('Due Date').value
+            due_date && due_date < now
+          end
+        end
+
+        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
+        end
+      
+    end
+  end
+end

data/lib/xeroizer/report/base.rb

@@ -0,0 +1,43 @@
+require 'xeroizer/report/base'
+require 'xeroizer/report/cell'
+require 'xeroizer/report/row/row'
+require 'xeroizer/report/row/header'
+require 'xeroizer/report/row/section'
+require 'xeroizer/report/row/summary'
+require 'xeroizer/report/xml_helper'
+
+module Xeroizer
+  module Report
+    class Base
+      
+      include XmlHelper
+      
+      attr_reader :factory
+      
+      attr_accessor :id
+      attr_accessor :name
+      attr_accessor :type
+      attr_accessor :titles
+      attr_accessor :date
+      attr_accessor :updated_at
+      
+      attr_accessor :rows
+      
+      attr_accessor :header
+      attr_accessor :summary
+      attr_accessor :sections
+            
+      public
+      
+        def initialize(factory)
+          @titles = []
+          @rows = []
+          @sections = []
+          @factory = factory
+        end
+      
+      protected
+                  
+    end
+  end
+end

data/lib/xeroizer/report/cell.rb

@@ -0,0 +1,32 @@
+require 'xeroizer/report/cell_xml_helper'
+
+module Xeroizer
+  module Report
+    class Cell
+      
+      include CellXmlHelper
+      
+      attr_accessor :value
+      attr_accessor :attributes
+      
+      public
+      
+        def initialize
+          @attributes = {}
+        end
+      
+        # Return first attribute's ID in the hash. Assumes there is only one as hashes get out of order.
+        # In all cases I've seen so far there is only one attribute returned.
+        def attribute_id
+          @attributes.each { | id, value | return id }
+        end
+        
+        # Return first attribute's value in the hash. Assumes there is only one as hashes get out of order.
+        # In all cases I've seen so far there is only one attribute returned.
+        def attribute_value
+          @attributes.each { | id, value | return value }
+        end
+      
+    end
+  end
+end