xero 0.0.1.1

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+spec/support/privatekey.pem

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in xero.gemspec
+gemspec

data/Guardfile

@@ -0,0 +1,8 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'rspec' do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Matt Beedle
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,29 @@
+# Xero
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'xero'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install xero
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/active_support/inflection_config.rb

@@ -0,0 +1,4 @@
+ActiveSupport::Inflector.inflections do |inflect|
+  inflect.irregular 'status', 'status'
+  inflect.irregular 'address', 'address'
+end

data/lib/active_support/inflections.rb

@@ -0,0 +1,3 @@
+ActiveSupport::Inflector.inflections do |inflect|
+  inflect.irregular 'status', 'status'
+end

data/lib/oauth/consumer.rb

@@ -0,0 +1,13 @@
+module OAuth
+  class Consumer
+
+    def http_with_ssl_client_certificates(*args)
+      @http ||= http_without_ssl_client_certificates(*args).tap do |http|
+        http.cert = options[:ssl_client_cert]
+        http.key  = options[:ssl_client_key]
+      end
+    end
+
+    alias_method_chain :http, :ssl_client_certificates
+  end
+end

data/lib/xero/associations/belongs_to.rb

@@ -0,0 +1,24 @@
+module Xero
+  module Associations
+    module BelongsTo
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+
+        def belongs_to(association_name, options = {})
+
+          attr_accessor :"#{association_name}_id"
+
+          define_method association_name do
+            instance_variable_get(:"#{association_name}")
+          end
+
+          define_method "#{association_name}=" do |value|
+            instance_variable_set(:"@#{association_name}", value)
+            send "#{association_name}_id", value.id
+          end
+        end
+      end
+    end
+  end
+end

data/lib/xero/associations/has_many.rb

@@ -0,0 +1,40 @@
+module Xero
+  module Associations
+    module HasMany
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def has_many(association_name, options = {})
+
+          define_method association_name do
+            var = instance_variable_get(:"@#{association_name}")
+            if var.blank?
+              var = HasManyProxy.new
+              instance_variable_set(:"@#{association_name}", var)
+            end
+            var
+          end
+
+          define_method "#{association_name}=" do |value|
+            if value.is_a?(Hash) && value[value.keys.first].is_a?(Array)
+              klass = options[:class_name] || association_name.to_s.singularize
+              klass = "Xero::Models::#{klass.to_s.classify}".constantize
+              value[value.keys.first].each do |item|
+                self.send(association_name).send :<<, klass.new(item)
+              end
+            end
+
+            # if value.is_a?(Hash)
+            #   klass = options[:class_name] || association_name.to_s.singularize
+            #   value = "Xero::Models::#{klass.to_s.classify}".constantize.
+            #     new(value)
+            # end
+            # instance_variable_set(
+            #   :"@#{association_name}", HasManyProxy.new(value)
+            # )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/xero/associations/has_many_proxy.rb

@@ -0,0 +1,20 @@
+module Xero
+  module Associations
+    class HasManyProxy < BasicObject
+
+      def initialize(*args)
+        @target = ::Array.new(*args)
+      end
+
+      protected
+
+      def target
+        @target
+      end
+
+      def method_missing(method, *args, &block)
+        target.send method, *args, &block
+      end
+    end
+  end
+end

data/lib/xero/associations/has_one.rb

@@ -0,0 +1,25 @@
+module Xero
+  module Associations
+    module HasOne
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def has_one(association_name, options = {})
+
+          define_method association_name do
+            instance_variable_get(:"@#{association_name}")
+          end
+
+          define_method "#{association_name}=" do |value|
+            if value.is_a?(Hash)
+              klass = options[:class_name] || association_name
+              value = "Xero::Models::#{klass.to_s.classify}".constantize.
+                new(value)
+            end
+            instance_variable_set(:"@#{association_name}", value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/xero/associations.rb

@@ -0,0 +1,11 @@
+module Xero
+  module Associations
+    extend ActiveSupport::Concern
+
+    included do
+      include Xero::Associations::BelongsTo
+      include Xero::Associations::HasMany
+      include Xero::Associations::HasOne
+    end
+  end
+end

data/lib/xero/client.rb

@@ -0,0 +1,83 @@
+module Xero
+  class Client
+    attr_accessor :client
+
+    def initialize(options = {})
+      self.client = OAuth::Consumer.new(
+        Xero.configuration.consumer_key,
+        Xero.configuration.consumer_secret, options
+      )
+    end
+
+    def contacts(options = {})
+      response = self.connection.get(Xero::Models::Contact.path, options)
+      contacts_attributes = hash_from_response(response, 'Contacts')
+      unless contacts_attributes.is_a?(Array)
+        contacts_attributes = [contacts_attributes]
+      end
+      contacts_attributes.map { |attrs| Xero::Models::Contact.new(attrs) }
+    end
+
+    def get_contact(contact_id)
+      response = self.connection.
+        get_by_id(Xero::Models::Contact.path, contact_id)
+      Xero::Models::Contact.new hash_from_response(response, 'Contacts')
+    end
+
+    def get_item(item_id)
+      response = self.connection.get_by_id(Xero::Models::Item.path, item_id)
+      Xero::Models::Item.new(hash_from_response(response, 'Items'))
+    end
+
+    def items(options = {})
+      response = self.connection.get(Xero::Models::Item.path, options)
+      items = hash_from_response(response, 'Items')
+      items.map { |item| Xero::Models::Item.new(item) }
+    end
+
+    def get_invoice(invoice_id)
+      response = self.connection.
+        get_by_id(Xero::Models::Invoice.path, invoice_id)
+      Xero::Models::Invoice.new hash_from_response(response, 'Invoices')
+    end
+
+    def invoices(options = {})
+      response = self.connection.get(Xero::Models::Invoice.path, options)
+      invoices_attributes = hash_from_response(response, 'Invoices')
+      unless invoices_attributes.is_a?(Array)
+        invoices_attributes = [invoices_attributes]
+      end
+      invoices_attributes.map { |attrs| Xero::Models::Invoice.new(attrs) }
+    end
+
+    def save(model)
+      model.tap do |item|
+        response = self.connection.post(model.class.path, model.to_xero_xml)
+        attrs = Hash.from_xml(response.body)['Response']['Items']['Item']
+        model.id = attrs["#{model.class.to_s.demodulize}ID"]
+        model.new_record = false
+      end
+    end
+
+    def build_item(attributes = {})
+      build_model Xero::Models::Item, attributes
+    end
+
+    def build_model(klass, item_attributes = {})
+      klass.new(item_attributes).tap do |item|
+        item.client = self
+      end
+    end
+
+    protected
+
+    def connection
+      @connection ||= Xero::Connection.new
+    end
+
+    def hash_from_response(response, klass_name)
+      attributes = Hash.from_xml(response.body)['Response']
+      attributes[klass_name][klass_name.singularize]
+    end
+  end
+end

data/lib/xero/clients/partner_application.rb

@@ -0,0 +1,6 @@
+module Xero
+  module Clients
+    class PartnerApplication
+    end
+  end
+end

data/lib/xero/clients/private_application.rb

@@ -0,0 +1,12 @@
+module Xero
+  module Clients
+    class PrivateApplication < Client
+      def connection
+        @connection ||= Xero::Connection.new(
+          signature_method: 'RSA-SHA1',
+          private_key_file: Xero.configuration.private_key_path
+        )
+      end
+    end
+  end
+end

data/lib/xero/configuration.rb

@@ -0,0 +1,14 @@
+module Xero
+  class Configuration
+
+    attr_accessor :logger, :consumer_key, :consumer_secret, :private_key_path
+
+    def logger
+      @logger || Logger.new(STDOUT)
+    end
+
+    def xero_url
+      'https://api.xero.com/api.xro/2.0'
+    end
+  end
+end

data/lib/xero/connection.rb

@@ -0,0 +1,62 @@
+module Xero
+  class Connection
+
+    attr_accessor :client, :consumer_options
+
+    def initialize(options = {})
+      self.consumer_options = {
+        site: 'https://api.xero.com',
+        request_token_path: '/oauth/RequestToken',
+        access_token_path: '/oauth/AccessToken',
+        authorize_path: '/oauth/Authorize'
+      }.reverse_merge(options)
+    end
+
+    def consumer
+      @consumer ||= ::OAuth::Consumer.new(
+        Xero.configuration.consumer_key,
+        Xero.configuration.consumer_secret,
+        self.consumer_options
+      )
+    end
+
+    def access_token
+      @access_token ||= ::OAuth::AccessToken.new(
+        consumer, Xero.configuration.consumer_key,
+        Xero.configuration.consumer_secret
+      )
+    end
+
+    def get_by_id(path, id)
+      make_request(:get, "#{path}/#{id}")
+    end
+
+    def get(path, params = {})
+      path = "#{path}?#{params.to_query}" unless params.blank?
+      make_request(:get, path)
+    end
+
+    def post(path, payload, params = {})
+      make_request(:post, path, { xml: payload })
+    end
+
+    private
+
+    def make_request(method, path, params = {})
+      uri = "#{Xero.configuration.xero_url}/#{path}"
+
+      headers = { 'charset' => 'utf-8' }
+
+      if method == :get
+        response = access_token.get(uri, params)
+      else
+        response = access_token.post(uri, params, headers)
+      end
+      handle_response(response)
+    end
+
+    def handle_response(response)
+      response
+    end
+  end
+end

data/lib/xero/models/account.rb

@@ -0,0 +1,66 @@
+module Xero
+  module Models
+
+    class Account < BaseModel
+
+      self.path = 'Accounts'
+
+      TYPE = {
+        'CURRENT' =>        '',
+        'FIXED' =>          '',
+        'PREPAYMENT' =>     '',
+        'EQUITY' =>         '',
+        'DEPRECIATN' =>     '',
+        'DIRECTCOSTS' =>    '',
+        'EXPENSE' =>        '',
+        'OVERHEADS' =>      '',
+        'CURRLIAB' =>       '',
+        'LIABILITY' =>      '',
+        'TERMLIAB' =>       '',
+        'OTHERINCOME' =>    '',
+        'REVENUE' =>        '',
+        'SALES' =>          ''
+      } unless defined?(TYPE)
+
+      TAX_TYPE = {
+        'NONE' =>             'No GST',
+        'EXEMPTINPUT' =>      'VAT on expenses exempt from VAT (UK only)',
+        'INPUT' =>            'GST on expenses',
+        'SRINPUT' =>          'VAT on expenses',
+        'ZERORATEDINPUT' =>   'Expense purchased from overseas (UK only)',
+        'RRINPUT' =>          'Reduced rate VAT on expenses (UK Only)', 
+        'EXEMPTOUTPUT' =>     'VAT on sales exempt from VAT (UK only)',
+        'ECZROUTPUT' =>       'EC Zero-rated output',
+        'OUTPUT' =>           'OUTPUT (old rate)',
+        'OUTPUT2' =>          'OUTPUT2',
+        'SROUTPUT' =>         'SROUTPUT',
+        'ZERORATEDOUTPUT' =>  'Sales made from overseas (UK only)',
+        'RROUTPUT' =>         'Reduced rate VAT on sales (UK Only)',
+        'ZERORATED' =>        'Zero-rated supplies/sales from overseas (NZ Only)'
+      } unless defined?(TAX_TYPE)
+
+      attribute :id
+      attribute :code
+      attribute :name
+      attribute :account_type
+      attribute :tax_type
+      attribute :description
+      attribute :system_account
+      attribute :enable_payments_to_account, type: Boolean
+      attribute :bank_account_number
+      attribute :currency_code
+
+      # def self.from_xml(xml)
+      #   attrs = Hash.from_xml(xml)['Accounts']['Account']
+
+      #   attrs['id'] = attrs.delete('AccountID')
+      #   attrs['account_type'] = attrs.delete('Type')
+      #   attrs.keys.each do |key|
+      #     attrs[key.tableize.singularize] = attrs.delete(key)
+      #   end
+
+      #   self.new(attrs)
+      # end
+    end
+  end
+end

data/lib/xero/models/address.rb

@@ -0,0 +1,28 @@
+module Xero
+  module Models
+    class Address < BaseModel
+
+      attribute :address_type
+      attribute :attention_to
+      attribute :address_line1
+      attribute :address_line2
+      attribute :address_line3
+      attribute :address_line4
+      attribute :city
+      attribute :region
+      attribute :postal_code
+      attribute :country
+
+      validates :address_type, presence: true
+      validates :attention_to, presence: true
+      validates :address_line1, presence: true
+      validates :city, presence: true
+      validates :region, presence: true
+      validates :postal_code, presence: true
+      validates :country, presence: true
+
+      belongs_to :contact
+      belongs_to :phone
+    end
+  end
+end

data/lib/xero/models/base_model.rb

@@ -0,0 +1,52 @@
+module Xero
+  module Models
+    class BaseModel
+      include ActiveAttr::Model
+      include Xero::Associations
+
+      class << self
+        attr_accessor :path
+      end
+
+      attribute :id
+
+      attr_accessor :new_record, :client
+
+      def initialize(attributes = {})
+        @new_record = true
+        cleanup_hash(attributes).each { |key, value| send("#{key}=", value) }
+      end
+
+      def save
+        raise StandardError if self.client.blank?
+        self.client.save(self)
+      end
+
+      def xero_attributes(attrs = nil)
+        attrs ||= attributes.clone
+        attrs.delete('id')
+        attrs.keys.each do |key|
+          value = attrs.delete(key)
+          value = xero_attributes(value) if value.is_a?(Hash)
+          attrs[key.to_s.camelize] = value.to_s
+        end
+        attrs
+      end
+
+      def cleanup_hash(hash)
+        hash.keys.each do |key|
+          value = hash.delete(key)
+          value = cleanup_hash(value) if value.is_a?(Hash)
+          key = key.to_s.underscore
+          key = 'id' if key.match(/_id/)
+          hash[key] = value
+        end
+        hash
+      end
+
+      def persisted?
+        id && !@new_record
+      end
+    end
+  end
+end

data/lib/xero/models/contact.rb

@@ -0,0 +1,27 @@
+module Xero
+  module Models
+    class Contact < Xero::Models::BaseModel
+
+      self.path = 'Contacts'
+
+      attribute :contact_number
+      attribute :name
+      attribute :first_name
+      attribute :last_name
+      attribute :contact_status
+      attribute :skype_user_name
+      attribute :bank_account_details
+      attribute :tax_number
+      attribute :accounts_receivable_tax_type
+      attribute :accounts_payable_tax_type
+      attribute :updated_date_utc, type: DateTime
+      attribute :is_supplier, type: Boolean
+      attribute :is_customer, type: Boolean
+      attribute :default_currency
+      attribute :email_address
+
+      has_many :addresses
+      has_many :phones
+    end
+  end
+end

data/lib/xero/models/invoice.rb

@@ -0,0 +1,37 @@
+module Xero
+  module Models
+    class Invoice < Xero::Models::BaseModel
+
+      self.path = 'Invoices'
+
+      attribute :type
+      attribute :date, type: Date
+      attribute :due_date, type: Date
+      attribute :line_amount_type
+      attribute :invoice_number
+      attribute :reference
+      attribute :url
+      attribute :currency_code
+      attribute :status
+      attribute :line_amount_types
+      attribute :subtotal, type: Float
+      attribute :total_tax, type: Float
+      attribute :total, type: Float
+      attribute :amount_due, type: Float
+      attribute :amount_paid, type: Float
+      attribute :amount_credited, type: Float
+      attribute :total_discount, type: Float
+      attribute :sub_total
+      attribute :updated_date_utc, type: DateTime
+      attribute :has_attachments, type: Boolean
+      attribute :sent_to_contact, type: Boolean
+      attribute :currency_rate
+
+      has_one :contact
+      has_many :line_items
+      has_many :payments
+
+      validates :type, presence: true
+    end
+  end
+end

data/lib/xero/models/item.rb

@@ -0,0 +1,26 @@
+module Xero
+  module Models
+    class Item < BaseModel
+
+      self.path = 'Items'
+
+      attribute :code
+      attribute :description
+      attribute :updated_date_utc, type: DateTime
+
+      validates :code, presence: true
+      validates :purchase_details, presence: true
+      validates :sales_details, presence: true
+
+      has_one :purchase_details, class_name: :item_detail
+      has_one :sales_details, class_name: :item_detail
+
+      def to_xero_xml
+        xero_attributes(attributes.clone).
+          merge('PurchaseDetails' => self.purchase_details.xero_attributes).
+          merge('SalesDetails' => self.sales_details.xero_attributes).
+          to_xml(root: 'Item')
+      end
+    end
+  end
+end