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

data/lib/xeroizer/record/base_model_http_proxy.rb

@@ -0,0 +1,141 @@
+require 'xeroizer/application_http_proxy'
+
+module Xeroizer
+  module Record
+    module BaseModelHttpProxy
+
+      def self.included(base)
+        base.send :include, Xeroizer::ApplicationHttpProxy
+        base.send :include, InstanceMethods
+      end
+
+      module InstanceMethods
+
+        protected
+
+          # Parse parameters for GET requests.
+          def parse_params(options)
+            params = {}
+            params[:ModifiedAfter]  = options[:modified_since] if options[:modified_since]
+            params[:includeArchived]  = options[:include_archived] if options[:include_archived]
+            params[:order]        = options[:order] if options[:order]
+            params[:createdByMyApp] = options[:createdByMyApp] if options[:createdByMyApp]
+
+            params[:IDs]            = filterize(options[:IDs]) if options[:IDs]
+            params[:InvoiceNumbers] = filterize(options[:InvoiceNumbers]) if options[:InvoiceNumbers]
+            params[:ContactIDs]     = filterize(options[:ContactIDs]) if options[:ContactIDs]
+            params[:Statuses]       = filterize(options[:Statuses]) if options[:Statuses]
+
+            if options[:where]
+              params[:where] =  case options[:where]
+                                  when String   then options[:where]
+                                  when Hash     then parse_where_hash(options[:where])
+                                end
+            end
+            params[:offset] = options[:offset] if options[:offset]
+            params[:Status] = options[:status] if options[:status]
+            params[:DateFrom] = options[:date_from] if options[:date_from]
+            params[:DateTo] = options[:date_to] if options[:date_to]
+            params[:page] = options[:page] if options[:page]
+            params
+          end
+
+          # Parse the :where part of the options for GET parameters and construct a valid
+          # .Net version of the criteria to pass to Xero.
+          #
+          # Attribute names can be modified as follows to change the expression used:
+          #   {attribute_name}_is_greater_than or {attribute_name}> uses '>'
+          #   {attribute_name}_is_greater_than_or_equal_to or {attribute_name}>= uses '>='
+          #   {attribute_name}_is_less_than or {attribute_name}< uses '<'
+          #   {attribute_name}_is_less_than_or_equal_to or {attribute_name}< uses '<='
+          #   DEFAULT: '=='
+          def parse_where_hash(where)
+            conditions = []
+            where.each do | key, value |
+              (attribute_name, expression) = extract_expression_from_attribute_name(key)
+              (_, field) = model_class.fields.find { | k, v | v[:internal_name] == attribute_name }
+              if field
+                conditions << where_condition_part(field, expression, value)
+              else
+                raise InvalidAttributeInWhere.new(model_name, attribute_name)
+              end
+            end
+            conditions.map { | (attr, expression, value) | "#{attr}#{expression}#{value}"}.join('&&')
+          end
+
+          # Extract the attribute name and expression from the attribute.
+          #
+          # @return [Array] containing [actual_attribute_name, expression]
+          def extract_expression_from_attribute_name(key)
+            case key.to_s
+              when /(_is_not|\<\>)$/
+                [
+                  key.to_s.gsub(/(_is_not|\<\>)$/, '').to_sym,
+                  '<>'
+                ]
+
+              when /(_is_greater_than|\>)$/
+                [
+                  key.to_s.gsub(/(_is_greater_than|\>)$/, '').to_sym,
+                  '>'
+                ]
+
+              when /(_is_greater_than_or_equal_to|\>\=)$/
+                [
+                  key.to_s.gsub(/(_is_greater_than_or_equal_to|\>\=)$/, '').to_sym,
+                  '>='
+                ]
+
+              when /(_is_less_than|\<)$/
+                [
+                  key.to_s.gsub(/(_is_less_than|\<)$/, '').to_sym,
+                  '<'
+                ]
+
+              when /(_is_less_than_or_equal_to|\<\=)$/
+                [
+                  key.to_s.gsub(/(_is_less_than_or_equal_to|\<\=)$/, '').to_sym,
+                  '<='
+                ]
+
+              else
+                [key, '==']
+
+            end
+          end
+
+          # Creates a condition part array containing the:
+          #   * Field's API name
+          #   * Expression
+          #   * .Net formatted value.
+          def where_condition_part(field, expression, value)
+            case field[:type]
+              when :guid        then ["#{field[:api_name]}.ToString()", expression, "\"#{value}\""]
+              when :string      then [field[:api_name], expression, "\"#{value}\""]
+              when :boolean     then [field[:api_name], expression, value ? 'true' : 'false']
+              when :integer     then [field[:api_name], expression, value.to_s]
+              when :decimal     then [field[:api_name], expression, value.to_s]
+              when :date        then [field[:api_name], expression, "DateTime.Parse(\"#{value.strftime("%Y-%m-%d")}\")"]
+              when :datetime    then [field[:api_name], expression, "DateTime.Parse(\"#{value.utc.strftime("%Y-%m-%dT%H:%M:%S")}\")"]
+              when :datetime_utc then [field[:api_name], expression, "DateTime.Parse(\"#{value.utc.strftime("%Y-%m-%dT%H:%M:%S")}\")"]
+              when :belongs_to  then
+              when :has_many    then
+              when :has_one    then
+            end
+          end
+
+        private
+
+          # Filtering params expect a comma separated list of strings 
+          def filterize(values)
+            case values
+              when String then values
+              when Array  then values.join(',')
+            end
+          end
+
+      end
+
+    end
+  end
+end

data/lib/xeroizer/record/model_definition_helper.rb

@@ -0,0 +1,101 @@
+module Xeroizer
+  module Record
+    module ModelDefinitionHelper
+      
+      def self.included(base)
+        base.extend(ClassMethods)
+        base.send :include, InstanceMethods
+      end
+      
+      module ClassMethods
+
+        # Possible primary keys. At least one of these must exist before attempting to update a record.
+        def set_possible_primary_keys(*args)
+          args = [args] unless args.is_a?(Array)
+          self.possible_primary_keys = args
+        end
+        
+        # Set the actual Xero primary key for this record.
+        def set_primary_key(primary_key_name)
+          self.primary_key_name = primary_key_name
+        end
+        
+        # Whether this record type's list results contain summary data only.
+        #
+        # Records like invoices, when returning a list, only show summary data for
+        # certain types of associations (like the contact record) and do not return
+        # any data for line items.
+        #
+        # Default: false
+        def list_contains_summary_only(status)
+          self.summary_only = status
+        end
+        
+        def list_contains_summary_only?
+          !!summary_only
+        end
+              
+        # Helper methods used to define the fields this model has.
+        def string(field_name, options = {});     define_simple_attribute(field_name, :string, options); end
+        def boolean(field_name, options = {});    define_simple_attribute(field_name, :boolean, options); end
+        def integer(field_name, options = {});    define_simple_attribute(field_name, :integer, options, 0); end
+        def decimal(field_name, options = {});    define_simple_attribute(field_name, :decimal, options, 0.0); end
+        def date(field_name, options = {});       define_simple_attribute(field_name, :date, options); end
+        def datetime(field_name, options = {});   define_simple_attribute(field_name, :datetime, options); end
+        def datetime_utc(field_name, options = {});   define_simple_attribute(field_name, :datetime_utc, options); end
+        
+        def guid(field_name, options = {})
+          # Ensure all automated Id conversions are changed to ID.
+          options[:api_name] ||= field_name.to_s.camelize.gsub(/Id/, 'ID')
+          define_simple_attribute(field_name, :guid, options)
+        end
+              
+        # Helper method to simplify field definition. 
+        # Creates an accessor and reader for the field.
+        # Options:
+        #   :internal_name => allows the specification of an internal field name differing from the API's field name.
+        #   :api_name => allows the API name to be specified if it can't be properly converted from camelize.
+        #   :model_name => allows class used for children to be different from it's ndoe name in the XML.
+        #   :type => type of field
+        #   :skip_writer => skip the writer method
+        def define_simple_attribute(field_name, field_type, options, value_if_nil = nil)
+          self.fields ||= {}
+          
+          internal_field_name = options[:internal_name] || field_name
+          self.fields[field_name] = options.merge({
+            :internal_name  => internal_field_name, 
+            :api_name       => options[:api_name] || field_name.to_s.camelize,
+            :type           => field_type
+          })
+          define_method internal_field_name do 
+            @attributes[field_name].nil? ? value_if_nil : @attributes[field_name]
+          end
+          
+          unless options[:skip_writer]
+            define_method "#{internal_field_name}=".to_sym do | value | 
+              parent.mark_dirty(self) if parent
+              @attributes[field_name] = value
+            end
+          end
+        end
+        
+      end
+      
+      module InstanceMethods
+        
+        # Returns the value of the Xero primary key for this record if it exists.
+        def id
+          self[self.class.primary_key_name]
+        end
+
+        # Sets the value of the Xero primary key for this record if it exists.
+        def id=(new_id)
+          parent.mark_dirty(self) if parent
+          self[self.class.primary_key_name] = new_id
+        end
+        
+      end
+      
+    end
+  end
+end

data/lib/xeroizer/record/payroll_base.rb

@@ -0,0 +1,29 @@
+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
+
+      def self.has_one(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

@@ -0,0 +1,141 @@
+module Xeroizer
+  module Record
+    module RecordAssociationHelper
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+
+        def belongs_to(field_name, options = {})
+          internal_field_name = options[:internal_name] || field_name
+          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)
+
+          # Create a #build_record_name method to build the record.
+          define_method "build_#{internal_singular_field_name}" do | *args |
+            attributes = args.size == 1 ? args.first : {}
+
+            # The name of the record model.
+            model_name = options[:model_name] ? options[:model_name].to_sym : field_name.to_s.singularize.camelize.to_sym
+
+            # The record's parent instance for this current application.
+            model_parent = new_model_class(model_name)
+
+            # Create a new record, binding it to it's parent instance.
+            record = (options[:base_module] || Xeroizer::Record).const_get(model_name).build(attributes, model_parent)
+            self.attributes[field_name] = record
+          end
+        end
+        
+        alias_method :has_one, :belongs_to
+
+        def has_many(field_name, options = {})
+          internal_field_name = options[:internal_name] || field_name
+          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.
+          define_method "add_#{internal_singular_field_name}" do | *args |
+            # The name of the record model.
+            model_name = options[:model_name] ? options[:model_name].to_sym : field_name.to_s.singularize.camelize.to_sym
+
+            # The record's parent instance for this current application.
+            model_parent = new_model_class(model_name)
+
+            # The class of this record.
+            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}, ...)
+            #   add_record(record_one, record_two, ...)
+            #   add_record([{fields}, {fields}], ...)
+            #   add_record(key => val, key2 => val)
+            records = []
+            if args.size == 1 && args.first.is_a?(Array)
+              records = args.first
+            elsif args.size > 0
+              records = args
+            else
+              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
+            self.send(internal_field_name)
+
+            # Add each record.
+            last_record = nil
+            records.each do | record |
+              record = record_class.build(record, model_parent) if record.is_a?(Hash)
+              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
+            end
+
+            last_record # last record
+          end
+
+        end
+     
+        def define_association_attribute(field_name, internal_field_name, association_type, options)
+          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 = 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 = (options[:base_module] || Xeroizer::Record).const_get(model_name)
+            case value
+              when Hash
+                self.attributes[field_name] = ((association_type == :has_many) ? [] : nil)
+                case association_type
+                  when :has_many
+                    self.attributes[field_name] = []
+                    self.send("add_#{internal_singular_field_name}".to_sym, value)
+                   
+                  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
+                self.attributes[field_name] = ((association_type == :has_many) ? [] : nil)
+                value.each do | single_value |
+                  case single_value
+                    when Hash         then send("add_#{internal_singular_field_name}".to_sym, single_value)
+                    when record_class then self.attributes[field_name] << single_value
+                    else                   raise AssociationTypeMismatch.new(record_class, single_value.class)
+                  end
+                end
+
+              when record_class
+                self.attributes[field_name] = ((association_type == :has_many) ? [value] : value)
+
+              when NilClass
+                self.attributes[field_name] = []
+
+              else
+                raise AssociationTypeMismatch.new(record_class, value.class)
+            end
+          end
+
+          # Override reader for this association if this association belongs
+          # to a summary-typed record. This will automatically attempt to download
+          # the complete version of the record before accessing the association.
+          if list_contains_summary_only?
+            define_method internal_field_name do
+              download_complete_record! unless new_record? || options[:list_complete] || options[:complete_on_page] && paged_record_downloaded? || complete_record_downloaded?
+              self.attributes[field_name] || ((association_type == :has_many) ? [] : nil)
+            end
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/xeroizer/record/validation_helper.rb

@@ -0,0 +1,75 @@
+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_length_of(*args)
+          validates_with_validator(Validator::LengthOfValidator, 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, _) | attr == attribute }.map { | (_, msg) | msg }
+          end
+        end
+        
+      end
+      
+    end
+  end
+end