xeroizer 2.17.1 → 3.0.0

data/lib/xeroizer/models/payroll/time_off_type.rb

@@ -0,0 +1,32 @@
+module Xeroizer
+  module Record
+    module Payroll
+
+      class TimeOffTypeModel < PayrollBaseModel
+
+        set_permissions :read
+
+      end
+
+      class TimeOffType < PayrollBase
+
+        TIME_OFF_CATEGORIES = {
+          'PAID' => '',
+          'UNPAID' => ''
+        } unless defined?(TIME_OFF_CATEGORIES)
+
+        set_primary_key :time_off_type_id
+
+        guid    :time_off_type_id
+        string  :time_off_type
+        string  :time_off_category
+        string  :expense_account_code
+        string  :liability_account_code
+        boolean :show_balance_to_employee
+
+        validates_inclusion_of :time_off_category, :in => TIME_OFF_CATEGORIES
+
+      end
+    end
+  end
+end

data/lib/xeroizer/models/payroll/work_location.rb

@@ -0,0 +1,25 @@
+module Xeroizer
+  module Record
+    module Payroll
+
+      class WorkLocationModel < PayrollBaseModel
+
+      end
+
+      class WorkLocation < PayrollBase
+
+        guid        :work_location_id
+        boolean     :is_primary
+        string      :street_address
+        string      :suite_or_apt_or_unit
+        string      :city
+        string      :state
+        string      :zip
+        decimal     :latitude
+        decimal     :longitude
+
+        validates_presence_of :work_location_id, :unless => :new_record?
+      end
+    end
+  end
+end

data/lib/xeroizer/models/prepayment.rb

@@ -25,6 +25,7 @@ module Xeroizer
       string        :reference
       decimal       :currency_rate
       decimal       :remaining_credit
+      decimal       :applied_amount
       boolean       :has_attachments
 
       belongs_to    :contact

data/lib/xeroizer/models/purchase_order.rb

@@ -30,15 +30,15 @@ module Xeroizer
       boolean :is_discounted 
       string  :reference
       string  :type
-      string  :currency_rate
+      decimal  :currency_rate
       string  :currency_code
-      guid  :branding_theme_id 
+      guid    :branding_theme_id 
       string  :status 
       string  :line_amount_types
-      string  :sub_total
-      string  :total_tax
-      string  :total 
-      date    :updated_date_UTC
+      decimal  :sub_total
+      decimal  :total_tax
+      decimal  :total 
+      datetime_utc :updated_date_utc, :api_name => 'UpdatedDateUTC'
       boolean :has_attachments
 
       has_many     :line_items

data/lib/xeroizer/models/quote.rb

@@ -0,0 +1,76 @@
+require "xeroizer/models/attachment"
+
+module Xeroizer
+  module Record
+
+    class QuoteModel < BaseModel
+      set_permissions :read, :write, :update
+
+      include AttachmentModel::Extensions
+
+      public
+
+        # Retrieve the PDF version of the quote matching the `id`.
+        # @param [String] id quote's ID.
+        # @param [String] filename optional filename to store the PDF in instead of returning the data.
+        def pdf(id, filename = nil)
+          pdf_data = @application.http_get(@application.client, "#{url}/#{CGI.escape(id)}", :response => :pdf)
+          if filename
+            File.open(filename, "wb") { | fp | fp.write pdf_data }
+            nil
+          else
+            pdf_data
+          end
+        end
+
+    end
+
+    class Quote < Base
+
+      QUOTE_STATUS = {
+        'DRAFT' =>    'A draft quote (default)',
+        'DELETED' =>  'A deleted quote',
+        'SENT' =>     'A quote that is marked as sent',
+        'DECLINED' => 'A quote that was declined by the customer',
+        'ACCEPTED' => 'A quote that was accepted by the customer',
+        'INVOICED' => 'A quote that has been invoiced'
+      } unless defined?(QUOTE_STATUS)
+      QUOTE_STATUSES = QUOTE_STATUS.keys.sort
+
+      include Attachment::Extensions
+
+      set_primary_key :quote_id
+      set_possible_primary_keys :quote_id, :quote_number
+      list_contains_summary_only false
+
+      guid         :quote_id
+      string       :quote_number
+      string       :reference
+      guid         :branding_theme_id
+      date         :date
+      date         :expiry_date
+      string       :status
+      string       :line_amount_types
+      decimal      :sub_total
+      decimal      :total_tax
+      decimal      :total
+      decimal      :total_discount
+      datetime_utc :updated_date_utc, :api_name => 'UpdatedDateUTC'
+      string       :currency_code
+      decimal      :currency_rate
+      string       :title
+      string       :summary
+      string       :terms
+      boolean      :has_attachments
+
+      belongs_to   :contact
+      has_many     :line_items
+
+      # Retrieve the PDF version of this quote.
+      # @param [String] filename optional filename to store the PDF in instead of returning the data.
+      def pdf(filename = nil)
+        parent.pdf(id, filename)
+      end
+    end
+  end
+end

data/lib/xeroizer/models/schedule.rb

@@ -10,6 +10,7 @@ module Xeroizer
       UNIT = {
         'WEEKLY'  => 'Weekly',
         'MONTHLY' => 'Monthly',
+        'YEARLY'  => 'Yearly',
       } unless defined?(UNIT)
 
       PAYMENT_TERM = {

data/lib/xeroizer/models/tax_component.rb

@@ -8,6 +8,7 @@ module Xeroizer
       string      :name
       decimal     :rate
       boolean     :is_compound
+      boolean     :is_non_recoverable
     end
   end
 end

data/lib/xeroizer/models/to_bank_account.rb

@@ -7,6 +7,7 @@ module Xeroizer
     class ToBankAccount < Base
       guid   :account_id
       string :code
+      string :name
     end
   end
 end

data/lib/xeroizer/oauth.rb

@@ -26,12 +26,23 @@ module Xeroizer
     class OAuthError < XeroizerError; end
     class TokenExpired < OAuthError; end
     class TokenInvalid < OAuthError; end
-    class RateLimitExceeded < OAuthError; end
     class ConsumerKeyUnknown < OAuthError; end
     class NonceUsed < OAuthError; end
     class OrganisationOffline < OAuthError; end
+    class Forbidden < OAuthError; end
     class UnknownError < OAuthError; end
 
+    class RateLimitExceeded < OAuthError
+      def initialize(description, retry_after: nil, daily_limit_remaining: nil)
+        super(description)
+
+        @retry_after = retry_after
+        @daily_limit_remaining = @daily_limit_remaining
+      end
+
+      attr_reader :retry_after, :daily_limit_remaining
+    end
+
     unless defined? XERO_CONSUMER_OPTIONS
       XERO_CONSUMER_OPTIONS = {
         :site               => "https://api.xero.com",

data/lib/xeroizer/oauth2.rb

@@ -0,0 +1,82 @@
+module Xeroizer
+  class OAuth2
+
+    attr_reader :client, :access_token
+
+    attr_accessor :tenant_id
+
+    def initialize(client_key, client_secret, options = {})
+      @client = ::OAuth2::Client.new(client_key, client_secret, options)
+    end
+
+    def authorize_url(options)
+      @client.auth_code.authorize_url(options)
+    end
+
+    def authorize_from_access(access_token, options = {})
+      @access_token = ::OAuth2::AccessToken.new(client, access_token, options)
+    end
+
+    def authorize_from_code(code, options = {})
+      @access_token = @client.auth_code.get_token(code, options)
+    end
+
+    def authorize_from_client_credentials(params = {}, options = {})
+      @access_token = @client.client_credentials.get_token(params, options)
+    end
+
+    def renew_access_token
+      @access_token = @access_token.refresh!
+    end
+
+    def get(path, headers = {})
+      wrap_response(access_token.get(path, headers: wrap_headers(headers)))
+    end
+
+    def post(path, body = "", headers = {})
+      wrap_response(access_token.post(path, {body: body, headers: wrap_headers(headers)}))
+    end
+
+    def put(path, body = "", headers = {})
+      wrap_response(access_token.put(path, body: body, headers: wrap_headers(headers)))
+    end
+
+    def delete(path, headers = {})
+      wrap_response(access_token.delete(path, headers: wrap_headers(headers)))
+    end
+
+    private
+
+    def wrap_headers(headers)
+      if tenant_id
+        headers.merge("Xero-tenant-id" => tenant_id)
+      else
+        headers
+      end
+    end
+
+    def wrap_response(response)
+      Response.new(response)
+    end
+
+    class Response
+      attr_reader :response
+
+      def initialize(response)
+        @response = response
+      end
+
+      def code
+        response.status
+      end
+
+      def success?
+        (200..299).to_a.include?(code)
+      end
+
+      def plain_body
+        response.body
+      end
+    end
+  end
+end

data/lib/xeroizer/oauth2_application.rb

@@ -0,0 +1,49 @@
+module Xeroizer
+  class OAuth2Application < GenericApplication
+
+    extend Forwardable
+    def_delegators :client,
+                   :authorize_from_access,
+                   :authorize_from_client_credentials,
+                   :authorize_from_code,
+                   :authorize_url,
+                   :renew_access_token,
+                   :tenant_id,
+                   :tenant_id=
+
+    public
+
+    # OAuth2 applications allow for connecting to Xero over OAuth2, as opposed to the
+    # Partner and Private applications which talk over OAuth1.
+    #
+    # @param [String] client_id client id/token from application developer (found at http://api.xero.com for your application).
+    # @param [String] client_secret client secret from application developer (found at http://api.xero.com for your application).
+    # @param [Hash] options other options to pass to the GenericApplication constructor
+    # @return [OAuth2Application] instance of OAuth2Application
+    def initialize(client_id, client_secret, options = {})
+      default_options = {
+        :xero_url         => 'https://api.xero.com/api.xro/2.0',
+        :site             => 'https://api.xero.com',
+        :authorize_url    => 'https://login.xero.com/identity/connect/authorize',
+        :token_url        => 'https://identity.xero.com/connect/token',
+        :tenets_url       => 'https://api.xero.com/connections',
+        :raise_errors     => false
+      }
+      options = default_options.merge(options)
+      client = OAuth2.new(client_id, client_secret, options)
+      super(client, options)
+
+      if options[:access_token]
+        authorize_from_access(options[:access_token], options)
+      end
+
+      if options[:tenant_id]
+        client.tenant_id = options[:tenant_id]
+      end
+    end
+
+    def current_connections
+      Connection.current_connections(client)
+    end
+  end
+end

data/lib/xeroizer/payroll_application.rb

@@ -1,6 +1,6 @@
 module Xeroizer
   class PayrollApplication
-    
+
     attr_reader :application
 
     # Factory for new Payroll BaseModel instances with the class name `record_type`.
@@ -15,11 +15,16 @@ module Xeroizer
           instance_variable_set(var_name, Xeroizer::Record::Payroll.const_get("#{record_type}Model".to_sym).new(self.application, record_type.to_s))
         end
         instance_variable_get(var_name)
-      end  
+      end
     end
 
     record :Employee
-    
+    record :PayRun
+    record :Paystub
+    record :PayItems
+    record :PaySchedule
+    record :LeaveApplication
+
     def initialize(application)
       @application = application
     end

data/lib/xeroizer/record/base.rb

@@ -30,7 +30,7 @@ module Xeroizer
         def build(attributes, parent)
           record = new(parent)
           attributes.each do | key, value |
-            attr = record.respond_to?("#{key}=") ? key : record.class.fields[key][:internal_name]
+            attr = record.respond_to?("#{key}=") || record.class.fields[key].nil? ? key : record.class.fields[key][:internal_name]
             record.send("#{attr}=", value)
           end
           record
@@ -105,12 +105,21 @@ module Xeroizer
         end
 
         def save
-          return false unless valid?
+          save!
+          true
+        rescue XeroizerError => e
+          log "[ERROR SAVING] (#{__FILE__}:#{__LINE__}) - #{e.message}"
+          false
+        end
+
+        def save!
+          raise RecordInvalid unless valid?
           if new_record?
             create
           else
             update
           end
+
           saved!
         end
 

data/lib/xeroizer/record/base_model.rb

@@ -116,7 +116,7 @@ module Xeroizer
         build(attributes).tap { |resource| resource.save }
       end
 
-      # Retreive full record list for this model.
+      # Retrieve full record list for this model.
       def all(options = {})
         raise MethodNotAllowed.new(self, :all) unless self.class.permissions[:read]
         response_xml = http_get(parse_params(options))

data/lib/xeroizer/record/base_model_http_proxy.rb

@@ -1,36 +1,45 @@
-require 'xeroizer/application_http_proxy' 
+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 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.
           #
@@ -46,14 +55,14 @@ module Xeroizer
               (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)                
+                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]
@@ -64,37 +73,37 @@ module Xeroizer
                   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
@@ -111,11 +120,22 @@ module Xeroizer
               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

@@ -68,7 +68,7 @@ module Xeroizer
             :type           => field_type
           })
           define_method internal_field_name do 
-            @attributes[field_name] || value_if_nil
+            @attributes[field_name].nil? ? value_if_nil : @attributes[field_name]
           end
           
           unless options[:skip_writer]

data/lib/xeroizer/record/payroll_base.rb

@@ -12,6 +12,10 @@ module Xeroizer
       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
 

data/lib/xeroizer/record/record_association_helper.rb

@@ -35,7 +35,7 @@ module Xeroizer
         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.
@@ -80,7 +80,7 @@ module Xeroizer
           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))
 
@@ -96,8 +96,8 @@ module Xeroizer
                   when :has_many
                     self.attributes[field_name] = []
                     self.send("add_#{internal_singular_field_name}".to_sym, value)
-
-                  when :belongs_to                  
+                   
+                  when :belongs_to  
                     self.attributes[field_name] = (options[:base_module] || Xeroizer::Record).const_get(model_name).build(value, new_model_class(model_name))
                    
                 end

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

@@ -22,6 +22,7 @@ module Xeroizer
               else
                 record.errors << [attribute, "must have one or more records"] 
               end
+
           end
         end