xeroizer-float 2.15.3.1

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/oauth.rb

@@ -0,0 +1,130 @@
+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 TokenExpired < StandardError; end
+    class TokenInvalid < StandardError; end
+    class RateLimitExceeded < StandardError; end
+    class UnknownError < StandardError; 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 [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)
+    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)
+      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
+      })
+      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
+        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/partner_application.rb

@@ -0,0 +1,46 @@
+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 [String] path_to_ssl_client_cert client-side SSL certificate file to use for requests
+      # @param [String] path_to_ssl_client_key client-side SSL private key to use for requests
+      # @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, path_to_ssl_client_cert, path_to_ssl_client_key, options = {})
+        default_options = {
+          :xero_url         => 'https://api-partner.network.xero.com/api.xro/2.0',
+          :site             => 'https://api-partner.network.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,
+          :ssl_client_cert  => OpenSSL::X509::Certificate.new(File.read(path_to_ssl_client_cert)),
+          :ssl_client_key   => OpenSSL::PKey::RSA.new(File.read(path_to_ssl_client_key))
+        )
+        super(consumer_key, consumer_secret, 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
+    
+  end
+end

data/lib/xeroizer/private_application.rb

@@ -0,0 +1,27 @@
+module Xeroizer
+  class PrivateApplication < GenericApplication
+    
+    extend Forwardable
+    def_delegators :client, :authorize_from_access
+
+    public
+   
+      # Private applications are defined in the Xero API website and can be accessed in the 
+      # background without ever requiring a redirect to the Xero website for authorisation.
+      # 
+      # @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 aapplication's private key for message signing (uploaded to http://api.xero.com)
+      # @param [Hash] options other options to pass to the GenericApplication constructor
+      # @return [PrivateApplication] instance of PrivateApplication
+      def initialize(consumer_key, consumer_secret, path_to_private_key, options = {})
+        options.merge!(
+          :signature_method => 'RSA-SHA1',
+          :private_key_file => path_to_private_key
+        )
+        super(consumer_key, consumer_secret, options)      
+        @client.authorize_from_access(consumer_key, consumer_secret)
+      end
+    
+  end
+end

data/lib/xeroizer/public_application.rb

@@ -0,0 +1,21 @@
+module Xeroizer
+  class PublicApplication < GenericApplication
+    
+    extend Forwardable
+    def_delegators :client, :request_token, :authorize_from_request, :authorize_from_access
+
+    public
+    
+      # Public appliations are authenticated via the Xero website via OAuth. AccessTokens are valid for 30 minutes
+      # after authentication. To extend this time you must redirect the user to Xero's OAuth server again.
+      # 
+      # @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 [Hash] options other options to pass to the GenericApplication constructor
+      # @return [PublicApplication] instance of PrivateApplication
+      def initialize(consumer_key, consumer_secret, options = {})
+        super(consumer_key, consumer_secret, options)
+      end
+
+  end
+end

data/lib/xeroizer/record/application_helper.rb

@@ -0,0 +1,32 @@
+module Xeroizer
+  module Record
+    module ApplicationHelper
+      
+      # Factory for new 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 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.const_get("#{record_type}Model".to_sym).new(self, record_type.to_s))
+          end
+          instance_variable_get(var_name)
+        end  
+      end
+      
+      def report(report_type)
+        define_method report_type do
+          var_name = "@#{report_type}_cache".to_sym
+          unless instance_variable_defined?(var_name)
+            instance_variable_set(var_name, Xeroizer::Report::Factory.new(self, report_type.to_s))
+          end
+          instance_variable_get(var_name)
+        end
+      end
+      
+    end
+  end
+end

data/lib/xeroizer/record/base.rb

@@ -0,0 +1,155 @@
+require 'xeroizer/record/model_definition_helper'
+require 'xeroizer/record/record_association_helper'
+require 'xeroizer/record/validation_helper'
+require 'xeroizer/record/xml_helper'
+require 'xeroizer/logging'
+
+module Xeroizer
+  module Record
+    
+    class Base
+      
+      include ClassLevelInheritableAttributes
+      class_inheritable_attributes :fields, :possible_primary_keys, :primary_key_name, :summary_only, :validators
+                 
+      attr_reader :attributes
+      attr_reader :parent
+      attr_accessor :errors
+      attr_accessor :complete_record_downloaded
+      
+      include ModelDefinitionHelper
+      include RecordAssociationHelper
+      include ValidationHelper
+      include XmlHelper
+      
+      class << self
+
+        # Build a record with attributes set to the value of attributes.
+        def build(attributes, parent)
+          record = new(parent)
+          attributes.each do | key, value |
+            record.send("#{key}=".to_sym, value)
+          end
+          record
+        end
+        
+      end
+      
+      public
+      
+        def initialize(parent)
+          @parent = parent
+          @attributes = {}
+        end
+        
+        def new_model_class(model_name)
+          Xeroizer::Record.const_get("#{model_name}Model".to_sym).new(parent.application, model_name.to_s)
+        end
+        
+        def [](attribute)
+          self.send(attribute)
+        end
+        
+        def []=(attribute, value)
+          self.send("#{attribute}=".to_sym, value)
+        end
+
+        def attributes=(new_attributes)
+          return unless new_attributes.is_a?(Hash)
+          new_attributes.each do | key, value |
+            self.send("#{key}=".to_sym, value)
+          end
+        end
+
+        def update_attributes(attributes)
+          self.attributes = attributes
+          save
+        end
+        
+        def new_record?
+          id.nil?
+        end
+        
+        # Check to see if the complete record is downloaded.
+        def complete_record_downloaded?
+          if !!self.class.list_contains_summary_only?
+            !!complete_record_downloaded
+          else
+            true
+          end
+        end
+        
+        # Downloads the complete record if we only have a summary of the record.
+        def download_complete_record!
+          record = self.parent.find(self.id)
+          @attributes = record.attributes if record
+          @complete_record_downloaded = true
+          self
+        end
+        
+        def save
+          return false unless valid?
+          if new_record?
+            create
+          else
+            update
+          end
+          @complete_record_downloaded = true
+          true
+        end
+
+        def inspect
+          attribute_string = self.attributes.collect do |attr, value|
+            "#{attr.inspect}: #{value.inspect}"
+          end.join(", ")
+          "#<#{self.class} #{attribute_string}>"
+        end
+                
+      protected
+      
+        # Attempt to create a new record.
+        def create
+          request = to_xml
+          log "[CREATE SENT] (#{__FILE__}:#{__LINE__}) #{request}"
+          
+          response = parent.http_put(request)
+          log "[CREATE RECEIVED] (#{__FILE__}:#{__LINE__}) #{response}"
+          
+          parse_save_response(response)
+        end
+        
+        # Attempt to update an existing record.
+        def update
+          if self.class.possible_primary_keys && self.class.possible_primary_keys.all? { | possible_key | self[possible_key].nil? }
+            raise RecordKeyMustBeDefined.new(self.class.possible_primary_keys)
+          end
+          
+          request = to_xml
+          
+          log "[UPDATE SENT] (#{__FILE__}:#{__LINE__}) \r\n#{request}"
+          
+          response = parent.http_post(request)
+
+          log "[UPDATE RECEIVED] (#{__FILE__}:#{__LINE__}) \r\n#{response}"
+
+          parse_save_response(response)
+        end
+        
+        # Parse the response from a create/update request.
+        def parse_save_response(response_xml)
+          response = parent.parse_response(response_xml)
+          record = response.response_items.first if response.response_items.is_a?(Array)
+          if record && record.is_a?(self.class)
+            @attributes = record.attributes
+          end
+          self
+        end
+
+        def log(what)
+          Xeroizer::Logging::Log.info what
+        end
+                     
+    end
+    
+  end
+end