xeroizer 2.18.1 → 3.0.1

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

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

@@ -33,6 +33,9 @@ module Xeroizer
                                 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
@@ -117,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/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
         

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)
@@ -22,14 +22,14 @@ module Xeroizer
                 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 :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  
+                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,10 +95,10 @@ 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.new(value).to_s
+                  when String       then BigDecimal(value).to_s
                   else              value
                 end
                 b.tag!(field[:api_name], real_value)
@@ -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) {

data/lib/xeroizer/report/aged_receivables_by_contact.rb

@@ -31,7 +31,7 @@ module Xeroizer
         end
 
         def sum(column_name, &block)
-          sections.first.rows.inject(BigDecimal.new('0')) do | sum, row |
+          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

data/lib/xeroizer/report/cell_xml_helper.rb

@@ -1,19 +1,19 @@
 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 
+          # Additionally, parse the attributes and return them as a hash to the
           # cell. If a cell's attributes look like:
           #
           #     <Attributes>
@@ -22,7 +22,7 @@ module Xeroizer
           #         <Id>account</Id>
           #       </Attribute>
           #     </Attributes>
-          # 
+          #
           # Return a hash like:
           #
           #     {
@@ -42,17 +42,17 @@ module Xeroizer
             end
             cell
           end
-          
+
         protected
 
           def parse_value(value)
             case value
-              when /^[-]?\d+(\.\d+)?$/                      then BigDecimal.new(value)
-              when /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}$/  then Time.xmlschema(value)
-              else                                          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
@@ -65,10 +65,10 @@ module Xeroizer
             [id, value]
           end
       end
-    
+
       module InstanceMethods
       end
-    
+
     end
   end
 end

data/lib/xeroizer/response.rb

@@ -1,9 +1,9 @@
 # Copyright (c) 2008 Tim Connor <tlconnor@gmail.com>
-# 
+#
 # Permission to use, copy, modify, and/or distribute this software for any
 # purpose with or without fee is hereby granted, provided that the above
 # copyright notice and this permission notice appear in all copies.
-# 
+#
 # THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 # WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 # MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
@@ -14,23 +14,23 @@
 
 module Xeroizer
   class Response
-    
+
     attr_accessor :id, :status, :errors, :provider, :date_time, :response_items, :request_params, :request_xml, :response_xml
-    
+
     class << self
-      
+
       # Parse the response retreived during any request.
       def parse(raw_response, request = {}, options = {}, &block)
         response = Xeroizer::Response.new
         response.response_xml = raw_response
-      
+
         doc = Nokogiri::XML(raw_response) { | cfg | cfg.noblanks }
-      
+
         # check for responses we don't understand
         raise Xeroizer::UnparseableResponse.new(doc.root.name) unless doc.root.name == 'Response'
-      
+
         doc.root.elements.each do | element |
-                    
+
           # Text element
           if element.children && element.children.size == 1 && element.children.first.text?
             case element.name
@@ -39,31 +39,36 @@ module Xeroizer
               when 'ProviderName' then response.provider = element.text
               when 'DateTimeUTC'  then response.date_time = Time.parse(element.text)
             end
-          
+
+          # Special case for Paystubs and PayItems because they are not wrapped in plural element or
+          # don't have singular children
+          elsif element.children && element.children.size > 0 && (element.name == 'Paystub' || element.name == 'PayItems')
+            yield(response, [element], element.name)
+
           # Records in response
           elsif element.children && element.children.size > 0
             yield(response, element.children, element.children.first.name)
           end
         end
-      
+
         response
       end
-      
+
     end
-    
+
     public
-    
+
       def initialize
         @response_items = []
       end
-    
+
       def success?
         status == 'OK'
       end
-      
+
       def error
         errors.blank? ? nil : errors[0]
       end
-      
+
   end
 end

data/lib/xeroizer/version.rb

@@ -1,3 +1,3 @@
 module Xeroizer
-  VERSION = "2.18.1".freeze
+  VERSION = "3.0.1".freeze
 end