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

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

@@ -0,0 +1,34 @@
+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/length_of_validator.rb

@@ -0,0 +1,23 @@
+module Xeroizer
+  module Record
+    
+    class Validator
+  
+      class LengthOfValidator < Validator
+        
+        def valid?(record)
+          if options[:max] && record.attributes[attribute].to_s.length > options[:max]
+            record.errors << [attribute, options[:message] || "must be shorter than #{options[:max]} characters"]
+          end
+
+          if options[:min] && record.attributes[attribute].to_s.length < options[:min]
+            record.errors << [attribute, options[:message] || "must be greater than #{options[:min]} characters"]
+          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,144 @@
+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, base_module)
+          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(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
+                when :belongs_to
+                  model_name = field[:model_name] ? field[:model_name].to_sym : element.name.to_sym
+                  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, inner_element |
+                      list << base_module.const_get(sub_field_name).build_from_node(inner_element, sub_parent, base_module)
+                    end
+                  end
+
+              end
+              if field[:calculated]
+                record.attributes[field[:internal_name]] = value
+              else
+                record.send("#{field[:internal_name]}=".to_sym, value)
+              end
+            end
+          end
+
+          parent.mark_clean(record)
+          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 |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]
+                  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) { |c| yield(c) }
+            else
+              yield(b)
+            end
+          end
+
+          # Format an 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(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")
+                  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)
+
+              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
+
+          def association_to_xml(association_name)
+            builder = Builder::XmlMarkup.new(indent: 2)
+            records = send(association_name)
+
+            optional_root_tag(association_name.to_s.camelize, builder) do |b|
+              records.each { |record| record.to_xml(b) }
+            end
+          end
+      end
+
+    end
+  end
+end

data/lib/xeroizer/report/aged_receivables_by_contact.rb

@@ -0,0 +1,42 @@
+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('0')) do | sum, row |
+            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,42 @@
+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

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 /\A[-]?\d+(\.\d+)?\z/                      then BigDecimal(value)
+              when /\A\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\z/  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