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

data/lib/xeroizer/models/to_bank_account.rb

@@ -0,0 +1,13 @@
+module Xeroizer
+  module Record
+    class ToBankAccountModel < BaseModel
+      set_permissions :read
+    end
+
+    class ToBankAccount < Base
+      guid   :account_id
+      string :code
+      string :name
+    end
+  end
+end

data/lib/xeroizer/models/tracking_category.rb

@@ -0,0 +1,23 @@
+module Xeroizer
+  module Record
+    
+    class TrackingCategoryModel < BaseModel
+      
+      set_permissions :read
+                  
+    end
+    
+    class TrackingCategory < Base
+      
+      set_primary_key :tracking_category_id
+      
+      guid   :tracking_category_id
+      string :name
+      string :status
+      
+      has_many :options
+      
+    end
+    
+  end
+end

data/lib/xeroizer/models/tracking_category_child.rb

@@ -0,0 +1,20 @@
+module Xeroizer
+  module Record
+    
+    class TrackingCategoryChildModel < BaseModel
+    
+      set_xml_root_name 'Tracking'
+      set_xml_node_name 'TrackingCategory'
+      
+    end
+    
+    class TrackingCategoryChild < Base
+      
+      string  :name
+      string  :option
+      guid    :tracking_category_id
+      
+    end
+    
+  end
+end

data/lib/xeroizer/models/user.rb

@@ -0,0 +1,26 @@
+module Xeroizer
+  module Record
+
+    class UserModel < BaseModel
+
+      set_api_controller_name 'User'
+      set_permissions :read
+
+    end
+
+    class User < Base
+
+      set_primary_key :user_id
+
+      guid         :user_id
+      string       :email_address
+      string       :first_name
+      string       :last_name
+      datetime_utc :updated_date_utc, :api_name => 'UpdatedDateUTC'
+      boolean      :is_subscriber
+      string       :organisation_role
+
+    end
+
+  end
+end

data/lib/xeroizer/oauth.rb

@@ -0,0 +1,162 @@
+# 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
+# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+# OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+module Xeroizer
+
+  # Shamelessly taken from the XeroGateway library by Tim Connor which is shamelessly
+  # based on the Twitter Gem's OAuth implementation by John Nunemaker
+  # Thanks!
+  #
+  # http://github.com/tlconnor/xero_gateway
+  # http://twitter.rubyforge.org/
+  # http://github.com/jnunemaker/twitter/
+
+  class OAuth
+    class OAuthError < XeroizerError; end
+    class TokenExpired < OAuthError; end
+    class TokenInvalid < 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",
+        :request_token_path => "/oauth/RequestToken",
+        :access_token_path  => "/oauth/AccessToken",
+        :authorize_path     => "/oauth/Authorize",
+        #:ca_file            => File.expand_path(File.join(File.dirname(__FILE__), 'ca-certificates.crt'))
+      }.freeze
+    end
+
+    # Mixin real OAuth methods for consumer.
+    extend Forwardable
+    def_delegators :access_token, :get, :post, :put, :delete
+
+    # @attr_reader [String] ctoken consumer key/token from application developer (found at http://api.xero.com for your application).
+    # @attr_reader [String] csecret consumer secret from application developer (found at http://api.xero.com for your application).
+    # @attr_reader [Time] expires_at time the AccessToken expires if using the PartnerApplication mode (usually 30 minutes for Xero).
+    # @attr_reader [Time] authorization_expires_at time the session expires if using the ParnterApplication mode (usually 365 days for Xero).
+    attr_reader :ctoken, :csecret, :consumer_options, :expires_at, :authorization_expires_at
+
+    # @attr_reader [String] session_handle session handle used to renew AccessToken if using the PartnerApplication mode.
+    # @attr_writer [String] session_handle session handle used to renew AccessToken if using the PartnerApplication mode.
+    attr_accessor :session_handle
+
+    # OAuth constructor.
+    #
+    # @param [String] ctoken consumer key/token from application developer (found at http://api.xero.com for your application).
+    # @param [String] csecret consumer secret from application developer (found at http://api.xero.com for your application).
+    # @option options [String] :access_token_path base URL path for getting an AccessToken (default: "/oauth/AccessToken")
+    # @option options [String] :authorize_path base URL path for authorising (default: "/oauth/Authorize")
+    # @option options [String] :ca_file file containing SSL root certificates (default: "lib/xeroizer/ca-certificates.crt")
+    # @option options [String] :private_key_file private key used when :signature_method set to RSA-SHA1 (used for PartnerApplication and PrivateApplication modes)
+    # @option options [String] :request_token_path base URL path for getting a RequestToken (default: "/oauth/RequestToken")
+    # @option options [String] :signature_method method usd to sign requests (default: OAuth library default)
+    # @option options [String] :site base site for API requests (default: "https://api.xero.com")
+    # @option options [IO] :http_debug_output filehandle to write HTTP traffic to
+    # @option options [OpenSSL:X509::Certificate] :ssl_client_cert client-side SSL certificate to use for requests (used for PartnerApplication mode)
+    # @option options [OpenSSL::PKey::RSA] :ssl_client_key client-side SSL private key to use for requests (used for PartnerApplication mode)
+    def initialize(ctoken, csecret, options = {})
+      @ctoken, @csecret = ctoken, csecret
+      @consumer_options = XERO_CONSUMER_OPTIONS.merge(options)
+    end
+
+    # OAuth consumer creator.
+    #
+    # @return [OAuth::Consumer] consumer object for GET/POST/PUT methods.
+    def consumer
+      create_consumer
+    end
+
+    # RequestToken for PUBLIC/PARTNER authorisation
+    # (used to redirect to Xero for authentication).
+    #
+    # @option params [String] :oauth_callback URL to redirect user to when they have authenticated your application with Xero. If not specified, the user will be shown an authorisation code on the screen that they need to get into your application.
+    def request_token(params = {})
+      consumer.get_request_token(params, {}, @consumer_options[:default_headers])
+    end
+
+    # Create an AccessToken from a PUBLIC/PARTNER authorisation.
+    def authorize_from_request(rtoken, rsecret, params = {})
+      request_token = ::OAuth::RequestToken.new(consumer, rtoken, rsecret)
+      access_token = request_token.get_access_token(params, {}, @consumer_options[:default_headers])
+      update_attributes_from_token(access_token)
+    end
+
+    # AccessToken created from authorize_from_access method.
+    def access_token
+      ::OAuth::AccessToken.new(consumer, @atoken, @asecret)
+    end
+
+    # Used for PRIVATE applications where the AccessToken uses the
+    # token/secret from Xero which would normally be used in the request.
+    # No request authorisation necessary.
+    #
+    # For PUBLIC/PARTNER applications this is used to recreate a client
+    # from a stored AccessToken key/secret.
+    def authorize_from_access(atoken, asecret)
+      @atoken, @asecret = atoken, asecret
+    end
+
+    # Renew an access token from a previously authorised token for a
+    # PARTNER application.
+    def renew_access_token(atoken = nil, asecret = nil, session_handle = nil)
+      old_token = ::OAuth::RequestToken.new(consumer, atoken || @atoken, asecret || @asecret)
+      access_token = old_token.get_access_token({
+        :oauth_session_handle => (session_handle || @session_handle),
+        :token => old_token
+      }, {}, @consumer_options[:default_headers])
+      update_attributes_from_token(access_token)
+    end
+
+    private
+
+      # Create an OAuth consumer with the SSL client key if specified in @consumer_options when
+      # this instance was created.
+      def create_consumer
+        consumer = ::OAuth::Consumer.new(@ctoken, @csecret, consumer_options)
+        if @consumer_options[:ssl_client_cert] && @consumer_options[:ssl_client_key]
+          consumer.http.cert = @consumer_options[:ssl_client_cert]
+          consumer.http.key = @consumer_options[:ssl_client_key]
+        end
+
+        if @consumer_options[:http_debug_output]
+          consumer.http.set_debug_output(@consumer_options[:http_debug_output])
+        end
+        consumer
+      end
+
+      # Update instance variables with those from the AccessToken.
+      def update_attributes_from_token(access_token)
+        @expires_at = Time.now + access_token.params[:oauth_expires_in].to_i
+        @authorization_expires_at = Time.now + access_token.params[:oauth_authorization_expires_in].to_i
+        @session_handle = access_token.params[:oauth_session_handle]
+        @atoken, @asecret = access_token.token, access_token.secret
+      end
+  end
+end

data/lib/xeroizer/oauth2.rb

@@ -0,0 +1,66 @@
+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_from_access(access_token, options = {})
+      @access_token = ::OAuth2::AccessToken.new(client, access_token)
+    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,42 @@
+module Xeroizer
+  class OAuth2Application < GenericApplication
+
+    extend Forwardable
+    def_delegators :client, :authorize_from_access, :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/partner_application.rb

@@ -0,0 +1,52 @@
+module Xeroizer
+  class PartnerApplication < GenericApplication
+
+    extend Forwardable
+    def_delegators :client, :request_token, :authorize_from_request, :renew_access_token, :expires_at, :authorization_expires_at, :session_handle, :authorize_from_access
+
+    public
+
+      # Partner applications allow for public AccessToken's received via the stanard OAuth
+      # authentication process to be renewed up until the session's expiry. The default session
+      # expiry for Xero is 365 days and the default AccessToken expiry is 30 minutes.
+      #
+      # @param [String] consumer_key consumer key/token from application developer (found at http://api.xero.com for your application).
+      # @param [String] consumer_secret consumer secret from application developer (found at http://api.xero.com for your application).
+      # @param [String] path_to_private_key application's private key for message signing (uploaded to http://api.xero.com)
+      # @param [Hash] options other options to pass to the GenericApplication constructor
+      # @return [PartnerApplication] instance of PrivateApplication
+      def initialize(consumer_key, consumer_secret, path_to_private_key, options = {})
+        default_options = {
+          :xero_url         => 'https://api.xero.com/api.xro/2.0',
+          :site             => 'https://api.xero.com',
+          :authorize_url    => 'https://api.xero.com/oauth/Authorize',
+          :signature_method => 'RSA-SHA1'
+        }
+        options = default_options.merge(options).merge(
+          :private_key_file => path_to_private_key
+        )
+        client = OAuth.new(consumer_key, consumer_secret, options)
+        super(client, options)
+
+        # Load up an existing token if passed the token/key.
+        if options[:access_token] && options[:access_key]
+          authorize_from_access(options[:access_token], options[:access_key])
+        end
+
+        # Save the session_handle if passed in so we can renew the token.
+        if options[:session_handle]
+          client.session_handle = options[:session_handle]
+        end
+      end
+
+    private
+
+      def read_certificate(cert)
+        if File.exists?(cert)
+          File.read(cert)
+        else
+          cert
+        end
+      end
+  end
+end

data/lib/xeroizer/payroll_application.rb

@@ -0,0 +1,33 @@
+module Xeroizer
+  class PayrollApplication
+
+    attr_reader :application
+
+    # Factory for new Payroll BaseModel instances with the class name `record_type`.
+    # Only creates the instance if one doesn't already exist.
+    #
+    # @param [Symbol] record_type Symbol of the record type (e.g. :Invoice)
+    # @return [BaseModel] instance of BaseModel subclass matching `record_type`
+    def self.record(record_type)
+      define_method record_type do
+        var_name = "@#{record_type}_cache".to_sym
+        unless instance_variable_defined?(var_name)
+          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
+
+    record :Employee
+    record :PayRun
+    record :Paystub
+    record :PayItems
+    record :PaySchedule
+    record :LeaveApplication
+
+    def initialize(application)
+      @application = application
+    end
+
+  end
+end