xeroizer 2.20.0 → 3.0.0

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

@@ -0,0 +1,29 @@
+module Xeroizer
+  module Record
+    module Payroll
+
+      class SalaryAndWageModel < PayrollBaseModel
+
+      end
+
+      class SalaryAndWage < PayrollBase
+
+        SALARY_AND_WAGE_TYPE = {
+          'HOURLY' => '',
+          'SALARY' => ''
+        } unless defined?(SALARY_AND_WAGE_TYPE)
+
+        guid          :salary_and_wages_id
+        guid          :earnings_type_id
+        string        :salary_wages_type
+        decimal       :hourly_rate
+        decimal       :annual_salary
+        decimal       :standard_hours_per_week
+        datetime      :effective_date
+
+        validates_presence_of :salary_and_wage_id, :unless => :new_record?
+        validates_inclusion_of :salary_wages_type, :in => SALARY_AND_WAGE_TYPE
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+module Xeroizer
+  module Record
+    module Payroll
+    
+      class SuperLineModel < PayrollBaseModel
+          
+      end
+      
+      class SuperLine < PayrollBase
+
+        SUPERANNUATION_CONTRIBUTION_TYPE = {
+          'SGC' => 'Mandatory 9% contribution',
+          'SALARYSACRIFICE' => 'Pre-tax reportable employer superannuation contribution, which is displayed separately on payment summaries',
+          'EMPLOYERADDITIONAL' => 'Additional employer superannuation contribution, which is displayed as RESC on payment summaries',
+          'EMPLOYEE' => 'Post-tax employee superannuation contribution'
+        } unless defined?(SUPERANNUATION_CONTRIBUTION_TYPE)
+        
+        SUPERANNUATION_CALCULATION_TYPE = {
+          'FIXEDAMOUNT' => 'For voluntary superannuation, the contribution amount can be a fixed rate or a percentage of earnings. For SGC contributions it must be a percentage',
+          'PERCENTAGEOFEARNINGS' => '',
+          'STATUTORY' => ''
+        } unless defined?(SUPERANNUATION_CALCULATION_TYPE)
+
+        guid  :super_membership_id, :api_name => 'SuperMembershipID'
+        string  :contribution_type
+        string  :calculation_type
+        integer :expense_account_code
+        integer :liability_account_code
+
+        decimal :minimum_monthly_earnings
+        decimal :percentage
+
+        validates_presence_of :super_membership_id, :contribution_type, :calculation_type, :expense_account_code, :liability_account_code, :unless => :new_record?
+        validates_inclusion_of :contribution_type, :in => SUPERANNUATION_CONTRIBUTION_TYPE
+        validates_inclusion_of :calculation_type, :in => SUPERANNUATION_CALCULATION_TYPE
+      end
+
+    end 
+  end
+end

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

@@ -0,0 +1,50 @@
+module Xeroizer
+  module Record
+    module Payroll
+    
+      class TaxDeclarationModel < PayrollBaseModel
+        set_xml_node_name 'TaxDeclaration'
+      end
+      
+      class TaxDeclaration < PayrollBase
+        
+        EMPLOYMENT_BASIS = {
+          'FULLTIME' => '',
+          'PARTTIME' => '',
+          'CASUAL' => '',
+          'LABOURHIRE' => '',
+          'SUPERINCOMESTREAM' => ''
+          
+        } unless defined?(EMPLOYMENT_BASIS)
+
+        TFN_EXEMPTION_TYPE = {
+          'NOTQUOTED' => 'Employee has not provided a TFN.',
+          'PENDING' => 'Employee has made a separate application or Enquiry to the ATO for a new or existing TFN.',
+          'PENSIONER' => 'Employee is claiming that they are in receipt of a pension, benefit or allowance.',
+          'UNDER18' => 'Employee is claiming an exemption as they are under the age of 18 and do not earn enough to pay tax.'
+        } unless defined?(TFN_EXEMPTION_TYPE)
+
+        string      :tax_file_number
+        
+        string      :tfn_exemption_type, :api_name => 'TFNExemptionType'
+        string      :employment_basis
+
+        boolean      :australian_resident_for_tax_purposes
+        boolean      :tax_free_threshold_claimed
+        boolean      :has_help_debt, :api_name => 'HasHELPDebt'
+        boolean      :has_sfss_debt, :api_name => 'HasSFSSDebt'
+        boolean      :eligible_to_receive_leave_loading
+
+        decimal      :tax_offset_estimated_amount
+        decimal      :upward_variation_tax_withholding_amount
+        decimal      :approved_withholding_variation_percentage
+
+        datetime_utc :updated_date_utc, :api_name => 'UpdatedDateUTC'
+        
+        validates_inclusion_of :employment_basis, :in => EMPLOYMENT_BASIS
+        validates_inclusion_of :tfn_exemption_type, :in => EMPLOYMENT_BASIS
+      end
+
+    end 
+  end
+end

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

@@ -0,0 +1,20 @@
+module Xeroizer
+  module Record
+    module Payroll
+
+      class TimeOffLineModel < PayrollBaseModel
+
+      end
+
+      class TimeOffLine < PayrollBase
+
+        guid :time_off_type_id, :api_name => 'TimeOffTypeID'
+        decimal :hours
+        decimal :balance
+
+        validates_presence_of :time_off_type_id, :unless => :new_record?
+      end
+
+    end
+  end
+end

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/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/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/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_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

@@ -120,6 +120,7 @@ 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
 

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
         

data/lib/xeroizer/record/xml_helper.rb

@@ -3,14 +3,14 @@ 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)
@@ -26,10 +26,10 @@ module Xeroizer
                 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  
+                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
@@ -51,13 +51,13 @@ module Xeroizer
           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|
@@ -70,9 +70,9 @@ module Xeroizer
               }
             end
           end
-          
+
         protected
-        
+
           # Add top-level root name if required.
           # E.g. Payments need specifying in the form:
           #   <Payments>
@@ -87,7 +87,7 @@ module Xeroizer
               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]
@@ -95,7 +95,7 @@ module Xeroizer
               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   
+              when :decimal
                 real_value = case value
                   when BigDecimal   then value.to_s
                   when String       then BigDecimal(value).to_s
@@ -111,13 +111,13 @@ module Xeroizer
                   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  
+              when :belongs_to
                 value.to_xml(b)
                 nil
 
-              when :has_many    
+              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) {