xeroizer 0.1.0

data/lib/xeroizer/models/manual_journal.rb

@@ -0,0 +1,42 @@
+module Xeroizer
+  module Record
+    
+    class ManualJournalModel < BaseModel
+        
+      set_permissions :read, :write, :update
+            
+    end
+    
+    class ManualJournal < Base
+      
+      JOURNAL_STATUS = {
+        'DRAFT' =>      'Draft',
+        'APPROVED' =>   'Approved'
+      } unless defined?(INVOICE_TYPE)
+      JOURNAL_STATUSES = JOURNAL_STATUS.keys.sort
+            
+      set_primary_key :manual_journal_id
+      set_possible_primary_keys :manual_journal_id
+      list_contains_summary_only true
+      
+      guid      :manual_journal_id
+      date      :date
+      string    :status
+      string    :line_amount_types
+      string    :narration
+      datetime  :updated_date_utc, :api_name => 'UpdatedDateUTC'
+      
+      has_many  :journal_lines, :model_name => 'ManualJournalLine'
+      
+      validates_presence_of :narration
+      validates_associated :journal_lines
+      
+      # Can only create/update manual journals in DRAFT status
+      validates_inclusion_of :status, :in => %w(DRAFT)
+      
+      public
+      
+    end
+    
+  end
+end

data/lib/xeroizer/models/manual_journal_line.rb

@@ -0,0 +1,24 @@
+module Xeroizer
+  module Record
+    
+    class ManualJournalLineModel < BaseModel
+                    
+    end
+    
+    class ManualJournalLine < Base
+
+      string    :description
+      string    :tax_type
+      string    :account_code
+      decimal   :line_amount
+      
+      has_many  :tracking, :model_name => 'TrackingCategoryChild'
+
+      validates_presence_of :account_code, :line_amount      
+            
+      public
+      
+    end
+    
+  end
+end

data/lib/xeroizer/models/option.rb

@@ -0,0 +1,15 @@
+module Xeroizer
+  module Record
+    
+    class OptionModel < BaseModel
+            
+    end
+    
+    class Option < Base
+      
+      string :name
+      
+    end
+    
+  end
+end

data/lib/xeroizer/models/organisation.rb

@@ -0,0 +1,23 @@
+module Xeroizer
+  module Record
+    
+    class OrganisationModel < BaseModel
+    
+      set_api_controller_name 'Organisation'
+      set_permissions :read
+      
+    end
+    
+    class Organisation < Base
+      
+      string :name
+      string :legal_name
+      boolean :pays_tax
+      string :version
+      string :organisation_type
+      string :base_currency
+      
+    end
+    
+  end
+end

data/lib/xeroizer/models/payment.rb

@@ -0,0 +1,30 @@
+module Xeroizer
+  module Record
+    
+    class PaymentModel < BaseModel
+        
+      set_permissions :write
+      
+    end
+    
+    class Payment < Base
+      
+      set_primary_key :payment_id
+      
+      guid      :payment_id
+      date      :date
+      decimal   :amount
+      string    :reference
+      
+      guid      :invoice_id
+      string    :invoice_number
+      guid      :account_id
+      string    :code
+      
+      belongs_to  :account
+      belongs_to  :invoice
+      
+    end
+    
+  end
+end

data/lib/xeroizer/models/phone.rb

@@ -0,0 +1,25 @@
+module Xeroizer
+  module Record
+    
+    class PhoneModel < BaseModel
+            
+    end
+    
+    class Phone < Base
+      
+      PHONE_TYPE = {
+        'DEFAULT' =>    'Default',
+        'DDI' =>        'Direct Dial-In',
+        'MOBILE' =>     'Mobile',
+        'FAX' =>        'Fax'
+      } unless defined?(PHONE_TYPE)
+
+      string :phone_type, :internal_name => :type
+      string :phone_number, :internal_name => :number
+      string :phone_area_code, :internal_name => :area_code
+      string :phone_country_code, :internal_name => :country_code
+      
+    end
+    
+  end
+end

data/lib/xeroizer/models/tax_rate.rb

@@ -0,0 +1,25 @@
+module Xeroizer
+  module Record
+    
+    class TaxRateModel < BaseModel
+            
+      set_permissions :read
+      
+    end
+    
+    class TaxRate < Base
+      
+      string  :name
+      string  :tax_type
+      boolean :can_apply_to_assets
+      boolean :can_apply_to_equity
+      boolean :can_apply_to_expenses
+      boolean :can_apply_to_liabilities
+      boolean :can_apply_to_revenue
+      decimal :display_tax_rate
+      decimal :effective_rate
+      
+    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,17 @@
+module Xeroizer
+  module Record
+    
+    class TrackingCategoryChildModel < BaseModel
+                  
+    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
+      @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 = {})
+      @request_token ||= 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
+      @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 || @secret)
+      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,44 @@
+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 = {})
+        options.merge!(
+          :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',
+          :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