xero-api 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f58c896bb749d9a48423d4af4b1a209b8ef3cce9aa94459b317e44b7b649f378
+  data.tar.gz: f738a3619bc044690bb01582849065b7ec253c183d03719a879af99952d555da
+SHA512:
+  metadata.gz: 7b8e83ddc7cb421258f60fe62c1adf38febf43383317ec0994219906414de8106a320527c7478d7d8b0e71f4322326a80f8aeef6d5b263146b0ac62ed2b78611
+  data.tar.gz: 2187ac8e2deb3ad9cbd54104e99b4e0673e9676102eb677e916c03071cbc95ed7693e5c8c32c30c3e955bc7311ee57a5146b3ad1df887b81c994a0acfb056049

data/.env.example_app.oauth1

@@ -0,0 +1,4 @@
+export XERO_API_CONSUMER_KEY=consumer-key-goes-here
+export XERO_API_CONSUMER_SECRET=consumer-secret-goes-here
+export XERO_API_ACCESS_TOKEN=access-token-goes-here
+export XERO_API_ACCESS_TOKEN_SECRET=access-token-secret-goes-here

data/.gitignore

@@ -0,0 +1,23 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+.env
+.ruby-version
+.ruby-gemset
+.byebug_history
+*.gem
+.rspec
+todo.txt
+*.sess
+*.log
+spec/temp/spec_status.txt
+*.swp
+scrap.txt
+README.md.html
+.DS_Store

data/.travis.yml

@@ -0,0 +1,15 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.4.4
+
+before_script:
+  - cp .env.example_app.oauth1 .env
+
+script:
+  - bundle exec rspec spec/
+
+
+notifications:
+  email:
+    - christian@minimul.com

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Christian Pelczarski
+
+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,214 @@
+# The xero-api gem
+
+### Ruby client for the Xero API version 2.
+- **Pure JSON-in / JSON-out.** No XML support.
+- 4 main methods: **.get, .create, .update, and .delete**
+- No validation rules built into the gem. **Validation comes from API only**.
+- Close to the metal experience.
+- First class logging.
+- Robust error handling.
+- Specs are built using real requests run directly against the Xero Demo Company. Thanks [VCR](https://github.com/vcr/vcr).
+- Built leveraging [Faraday](https://github.com/lostisland/faraday).
+- Built knowing that OAuth2 might be in the not-to-distant future.
+
+## Why another library when there are other more mature, established Ruby Xero libraries?
+
+Both of the current de facto Ruby Xero client gems were built 6+ years ago when the Xero API was XML only, therefore, they are loaded with *XML cruft*.
+For example, here are the total code line counts (of `.rb` files):
+
+- Total LOC count of :
+  - **minimul/xero-api** => **910!** 🌈
+  - waynerobinson/xeroizer => 6019
+  - xero-gateway/xero_gateway => 5545
+
+## Ruby >= 2.4.0 required
+
+## Current Limitations
+
+- Accounting API only.
+- Only for public and partner Xero apps.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'xero_api'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install xero-api
+
+
+## Initialize
+
+```ruby
+  creds = account.xero_account # or wherever you are storing the OAuth creds
+  xero_api = Xero::Api.new(token: creds.token,
+                       token_secret: creds.secret,
+                       consumer_key: '*****',
+                       consumer_secret: '********')
+```
+
+## .get
+
+### Important
+One queries the Xero API [mostly using URL parameters](https://developer.xero.com/documentation/api/requests-and-responses) so `xero-api` doesn't do a lot of "hand holding" and has the `params` argument enabling you to craft your queries as you see fit. Likewise, the `path` argument allows you to forge the URL path you desire. The `params` and `path` arguments are available on `.create`, `.update`, `delete`, and `.upload_attachment` as well.
+
+```ruby
+  # Basic get - retrieves first 100 contacts
+  resp = api.get(:contacts)
+  # Retrieves all contacts - returns Enumerator so you can do cool stuff
+  resp = api.get(:contacts, all: true)
+  p resp.count #=> 109
+  # Retrieves all contacts modified after a certain date
+  resp = api.get(:items, all: true, modified_since: Time.utc(2014, 01, 01))
+  # Retrieves only customers
+  resp = api.get(:contacts, params: { where: 'IsCustomer=true' })
+  # Retrieve by id
+  resp = api.get(:contacts, id: '323-43fss-4234dfa-3432233')
+  # Retrieve with custom path
+  resp = api.get(:users, path: '3138017f-8ddc-420e-a159-e7e1cf9e643d/History')
+```
+
+See all the arguments for the [`.get` method](https://github.com/minimul/xero-api/blob/447170ff1035103ed251bf203cf95450bda0f377/lib/xero/api/methods.rb#L4).
+
+## .create
+
+```ruby
+  payload = {
+      "Type": "ACCREC",
+      "Contact": { 
+        "ContactID": "f477ad8d-44f2-4bb7-a99b-04f28681e849" 
+      },
+      "DateString": api.standard_date(Time.utc(2009, 05, 27)),
+      "DueDateString": api.standard_date(Time.utc(2009, 06, 06)),
+      "LineAmountTypes": "Exclusive",
+      "LineItems": [
+        {
+          "Description": "Consulting services as agreed (20% off standard rate)",
+          "Quantity": "10",
+          "UnitAmount": "100.00",
+          "AccountCode": "200",
+          "DiscountRate": "20"
+        }
+      ]
+  }
+  response = api.create(:invoice, payload: payload)
+  inv_num = response.dig("Invoices", 0, "InvoiceNumber")
+  p inv_num #=> 'INV-0041'
+```
+
+##### bulk .create
+```ruby
+  payload = { "Contacts": [] }
+  60.times do
+    payload[:Contacts] << { "Name": Faker::Name.unique.name, "IsCustomer": true }
+  end
+  resp = api.create(:contacts, payload: payload, params: { summarizeErrors: false })
+  p resp.dig("Contacts").size #=> 60
+```
+
+See all the arguments for the [`.create` method](https://github.com/minimul/xero-api/blob/447170ff1035103ed251bf203cf95450bda0f377/lib/xero/api/methods.rb#L14).
+
+## .update
+
+```ruby
+  payload = {
+    "InvoiceNumber": 'INV-0038',
+    "Status": 'VOIDED'
+  }
+  response = api.update(:invoices, id: 'INV-0038', payload: payload)
+  p response.dig("Invoices", 0, "Status") #=> VOIDED
+```
+
+See all the arguments for the [`.update` method](https://github.com/minimul/xero-api/blob/447170ff1035103ed251bf203cf95450bda0f377/lib/xero/api/methods.rb#L19).
+
+## .delete
+
+```ruby
+  api.delete(:items, id: "e1d100f5-a602-4f0e-94b7-dc12e97b9bc2")
+```
+See all the arguments for the [`.delete` method](https://github.com/minimul/xero-api/blob/447170ff1035103ed251bf203cf95450bda0f377/lib/xero/api/methods.rb#L25).
+
+## Configuration options
+```
+- Logging:
+```ruby
+Xero::Api.log = true
+```
+- To change logging target from `$stdout` e.g.
+```ruby
+Xero::Api.logger = Rails.logger
+```
+
+## Other stuff
+
+### .upload_attachment
+```ruby
+  file_name = 'connect_xero_button_blue_2x.png'
+  resp = api.upload_attachment(:invoices, id: '9eb7b996-4ac6-4cf8-8ee8-eb30d6e572e3', 
+                               file_name: file_name, content_type: 'image/png',
+                               attachment: "#{__dir__}/../../../example/public/#{file_name}")
+```
+
+### Respond to an error
+```ruby
+  customer = { Name: 'Already Exists', EmailAddress: 'newone@already.com' }
+  begin
+    response = api.create(:contacts, payload: customer)
+  rescue Xero::Api::BadRequest => e
+    if e.message =~ /already exists/
+      # Query for Id using Name
+      resp = api.get(:contacts, params: { where: "Name='Already Exists'" })
+      # Do an update instead
+      up_resp = api.update(:contacts, id: resp["Id"], payload: payload)
+    end
+  end
+```
+
+### Spin up an example
+
+1. Follow and do all in Step 1 from the [Getting Started Guide](https://developer.xero.com/documentation/getting-started/getting-started-guide).
+1. `git clone git://github.com/minimul/xero-api && cd xero-api`
+1. `bundle`
+1. Create a `.env` file
+  1. `cp .env.example_app.oauth1 .env`
+  1. Edit the `.env` file values with `consumer_key` and `consumer_secret`.
+1. Start up the example app => `ruby example/oauth.rb`
+1. In browser go to `http://localhost:9393`.
+1. Use the `Connect to Xero` button to connect to your Xero account.
+1. After successfully connecting click on the displayed link => `View All Customers`
+1. Checkout [`example/oauth.rb`](https://github.com/minimul/xero-api/blob/master/example/oauth.rb)
+  to see what is going on under the hood.
+  - **Important:** In the [`/auth/xero/callback`](https://github.com/minimul/xero-api/blob/master/example/oauth.rb) route there is code there that will automatically update your `.env` file.
+
+### Protip: Once your .env file is completely filled out you can use the console to play around in your sandbox
+```
+bin/console test
+>> @xero_api.get :contacts, id: '5345-as543-4-afgafadsafsad-45334'
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/minimul/xero-api.
+
+#### Running the specs
+- `git clone git://github.com/minimul/xero-api && cd xero-api`
+- `bundle`
+- Create a `.env` file
+  - `cp .env.example_app.oauth1 .env`
+- `bundle exec rake`
+
+#### Creating new specs or modifying existing spec that have been recorded using the VCR gem.
+- All specs that require interaction with the API must be recorded against the Xero Demo Company. 
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require_relative '../lib/xero/api'
+
+if ARGV[0] == "test"
+  require_relative '../spec/support/credentials'
+  ARGV[0] = nil # needed to avoid irb error
+  instance_variable_set(:@xero_api, Xero::Api.new(creds.to_h))
+end
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/example/base.rb

@@ -0,0 +1,36 @@
+BASE_GEMS = proc do
+  gem 'xero-api', path: '.'
+  # This app
+  gem 'sinatra'
+  gem 'sinatra-contrib'
+
+  # Creds from ../.env
+  gem 'dotenv'
+end
+
+BASE_SETUP = proc do
+  # Webhook support
+  require 'json'
+  require 'openssl'
+  require 'base64'
+
+  Dotenv.load "#{__dir__}/../.env"
+end
+
+BASE_APP_CONFIG = proc do
+  PORT  = ENV.fetch("PORT", 9393)
+
+  configure do
+    $VERBOSE = nil # silence redefined constant warning
+    register Sinatra::Reloader
+  end
+
+  set :port, PORT
+
+  helpers do
+    def base_url
+      "http://localhost:#{PORT}"
+    end
+  end
+
+end

data/example/oauth.rb

@@ -0,0 +1,67 @@
+require 'bundler/inline'
+
+require File.expand_path(File.join('..', 'base'), __FILE__)
+
+install_gems = true
+gemfile(install_gems) do
+  source 'https://rubygems.org'
+
+  instance_eval(&BASE_GEMS)
+
+  gem 'simple_oauth'
+  gem 'omniauth'
+  gem 'omniauth-xero'
+end
+
+instance_eval(&BASE_SETUP)
+
+class OAuthApp < Sinatra::Base
+  instance_eval(&BASE_APP_CONFIG)
+
+  CONSUMER_KEY = ENV['XERO_API_CONSUMER_KEY']
+  CONSUMER_SECRET = ENV['XERO_API_CONSUMER_SECRET']
+
+  use Rack::Session::Cookie, secret: '34233adasfqewrq453agqr9lasfa'
+  use OmniAuth::Builder do
+    provider :xero, CONSUMER_KEY, CONSUMER_SECRET
+  end
+
+  get '/' do
+    @auth_data = oauth_data
+    @port = PORT
+    erb :index
+  end
+
+  get '/customers' do
+    if session[:token]
+      api = Xero::Api.new(oauth_data)
+      @resp = api.get :contacts, all: true, params: { where: 'isCustomer=true' }
+    end
+    erb :customers
+  end
+
+  get '/auth/xero/callback' do
+    auth = env["omniauth.auth"][:credentials]
+    session[:token] = auth[:token]
+    session[:secret] = auth[:secret]
+    file_name = "#{__dir__}/../.env"
+    if env = File.read(file_name)
+      res = env.sub(/(XERO_API_ACCESS_TOKEN=)(.*)/, '\1' + session[:token])
+      res = res.sub(/(XERO_API_ACCESS_TOKEN_SECRET=)(.*)/, '\1' + session[:secret])
+      File.open(file_name, "w") {|file| file.puts res }
+    end
+    @url = base_url
+    erb :callback
+  end
+
+  def oauth_data
+    {
+      consumer_key: CONSUMER_KEY,
+      consumer_secret: CONSUMER_SECRET,
+      token: session[:token],
+      token_secret: session[:secret]
+    }
+  end
+end
+
+OAuthApp.run!

data/example/views/callback.erb

@@ -0,0 +1,20 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <title>Callback page</title>
+  </head>
+  <body>
+    <h3>Redirecting ...</h3>
+  <script>
+    setTimeout(function(){
+      var url = '<%= @url %>'; 
+      if(window.opener == null){
+        window.location = url;
+      }else{
+        window.opener.location = url;
+        window.close();
+      }
+    }, 5000);
+  </script>
+  </body>
+</html>

data/example/views/customers.erb

@@ -0,0 +1,20 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8">
+    <title>My Xero Customers</title>
+  </head>
+  <body>
+    <h2>Here's the code that is powering this view.</h2>
+    <pre>
+      api = Xero::Api.new(oauth_data)
+      @resp = api.get :customers, all: true, params: { where: 'isCustomer=true' }
+    </pre>
+    <h1>Customers within your Xero Account</h1>
+    <ul>
+    <% @resp.each do |c, index|  %>
+      <li><strong><%= c['Name'] %></strong></li>      
+    <% end %>
+    </ul>
+  </body>
+</html>

data/example/views/index.erb

@@ -0,0 +1,20 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="UTF-8">
+    <title>Xero Connect</title>
+  </head>
+  <body>
+    <a href="<%= base_url %>/auth/xero">
+      <img src="/connect_xero_button_blue_2x.png" alt="Xero Blue Connect Button" />
+    </a>
+    <% if session[:token] %>
+      <ul>
+        <li>Token: <input type="text" value="<%= session[:token] %>" size="100" /></li>
+        <li>Secret: <input type="text" value="<%= session[:secret] %>" size="100" /></li>
+        <li><strong><a href="/customers">View All Customers</a></strong></li>
+      </ul>
+    <% end %>
+
+  </body>
+</html>

data/lib/xero/api.rb

@@ -0,0 +1,55 @@
+require 'json'
+require 'uri'
+require 'logger'
+require_relative 'api/version'
+require_relative 'api/configuration'
+require_relative 'api/connection'
+require_relative 'api/error'
+require_relative 'api/raise_http_exception'
+require_relative 'api/util'
+require_relative 'api/attachment'
+require_relative 'api/methods'
+
+module Xero
+  class Api
+    extend Configuration
+    include Connection
+    include Util
+    include Attachment
+    include Methods
+
+    attr_accessor :endpoint
+
+    V2_ENDPOINT_BASE_URL  = 'https://api.xero.com/api.xro/2.0/'
+    LOG_TAG = "[xero-api gem]"
+
+    def initialize(attributes = {})
+      raise Xero::Api::Error, "missing or blank keyword: token" unless attributes.key?(:token) and !attributes[:token].nil?
+      attributes = default_attributes.merge!(attributes)
+      attributes.each do |attribute, value|
+        public_send("#{attribute}=", value)
+      end
+      @endpoint_url = get_endpoint
+    end
+
+    def default_attributes
+      {
+        endpoint: :accounting
+      }
+    end
+
+    def connection(url: endpoint_url)
+      @connection ||= authorized_json_connection(url)
+    end
+
+    def endpoint_url
+      @endpoint_url.dup
+    end
+
+    private
+
+    def get_endpoint
+      V2_ENDPOINT_BASE_URL
+    end
+  end
+end

data/lib/xero/api/attachment.rb

@@ -0,0 +1,26 @@
+class Xero::Api
+  module Attachment
+
+    def upload_attachment(entity, id:, file_name:, content_type:, attachment:, include_online: false)
+      url = "#{entity_handler(entity)}/#{id}/Attachments/#{file_name}"
+      url += "?IncludeOnline=true" if include_online
+      headers = { 'Content-Type' => content_type, 'Accept' => 'application/json' }
+      raw_response = attachment_connection(headers: headers).post do |request|
+        request.url url 
+        request.body = Faraday::UploadIO.new(attachment, content_type, file_name)
+      end
+      response(raw_response, entity: entity)
+    end
+
+    def attachment_connection(headers:)
+      build_connection(endpoint_url, headers: headers) do |conn|
+        add_authorization_middleware(conn)
+        add_exception_middleware(conn)
+        conn.request :url_encoded
+        add_connection_adapter(conn)
+      end
+    end
+
+  end
+end
+

data/lib/xero/api/configuration.rb

@@ -0,0 +1,21 @@
+class Xero::Api
+  module Configuration
+
+    def logger
+      @logger ||= ::Logger.new($stdout)
+    end
+
+    def logger=(logger)
+      @logger = logger
+    end
+
+    def log
+      @log ||= false
+    end
+
+    def log=(value)
+      @log = value
+    end
+
+  end
+end

data/lib/xero/api/connection.rb

@@ -0,0 +1,114 @@
+require 'faraday'
+require 'faraday_middleware'
+require 'faraday/detailed_logger'
+
+class Xero::Api
+  module Connection
+    AUTHORIZATION_MIDDLEWARES = []
+
+    def Connection.add_authorization_middleware(strategy_name)
+      Connection::AUTHORIZATION_MIDDLEWARES << strategy_name
+    end
+
+    def authorized_json_connection(url, headers: nil)
+      headers ||= {}
+      headers['Accept'] ||= 'application/json' # required "we'll only accept JSON". Can be changed to any `+json` media type.
+      headers['Content-Type'] ||= 'application/json;charset=UTF-8' # required when request has a body, else harmless
+      build_connection(url, headers: headers) do |conn|
+        add_authorization_middleware(conn)
+        add_exception_middleware(conn)
+        conn.request :url_encoded
+        add_connection_adapter(conn)
+      end
+    end
+
+    def authorized_multipart_connection(url)
+      headers = { 'Content-Type' => 'multipart/form-data' }
+      build_connection(url, headers: headers) do |conn|
+        add_authorization_middleware(conn)
+        add_exception_middleware(conn)
+        conn.request :multipart
+        add_connection_adapter(conn)
+      end
+    end
+
+    def build_connection(url, headers: nil)
+      Faraday.new(url: url) { |conn|
+        conn.response :detailed_logger, Xero::Api.logger, LOG_TAG if Xero::Api.log
+        conn.headers.update(headers) if headers
+        yield conn if block_given?
+      }
+    end
+
+    def request(method, path:, entity: nil, payload: nil, headers: nil, parse_entity: false)
+      raw_response = raw_request(method, conn: connection, path: path, payload: payload, headers: headers)
+      response(raw_response, entity: entity, parse_entity: parse_entity)
+    end
+
+    def raw_request(method, conn:, path:, payload: nil, headers: nil)
+      conn.public_send(method) do |req|
+        req.headers.update(headers) if headers
+        case method
+        when :get, :delete
+          req.url path
+        when :post, :put
+          req.url path
+          req.body = payload.to_json
+        else raise Xero::Api::Error, "Unhandled request method '#{method.inspect}'"
+        end
+      end
+    end
+
+    def response(resp, entity: nil, parse_entity: false)
+      data = parse_response_body(resp)
+      parse_entity && entity ? entity_response(data, entity) : data
+    rescue => e
+      msg = "#{LOG_TAG} response parsing error: entity=#{entity.inspect} body=#{resp.body.inspect} exception=#{e.inspect}"
+      Xero::Api.logger.debug { msg }
+      data
+    end
+
+    def parse_response_body(resp)
+      body = resp.body
+      case resp.headers['Content-Type']
+      when /json/ then JSON.parse(body)
+      else body
+      end
+    end
+
+    private
+
+    def entity_response(data, entity)
+      entity_name = entity_handler(entity)
+      entity_body = data
+      entity_body.fetch(entity_name) do
+        msg = "#{LOG_TAG} entity name not in that top-level of the response body: entity_name=#{entity_name}"
+        Xero::Api.logger.debug { msg }
+        data
+      end
+    end
+
+    def add_connection_adapter(conn)
+      conn.adapter Faraday.default_adapter
+    end
+
+    def add_exception_middleware(conn)
+      conn.use FaradayMiddleware::RaiseHttpException
+    end
+
+    def add_authorization_middleware(conn)
+      Connection::AUTHORIZATION_MIDDLEWARES.find(proc do
+        raise Xero::Api::Error, 'Add a configured authorization_middleware'
+      end) do |strategy_name|
+        next unless public_send("use_#{strategy_name}_middleware?")
+        public_send("add_#{strategy_name}_authorization_middleware", conn)
+        true
+      end
+    end
+
+    require_relative 'connection/oauth1'
+    include OAuth1
+    require_relative 'connection/oauth2'
+    include OAuth2
+  end
+end

data/lib/xero/api/connection/oauth1.rb

@@ -0,0 +1,51 @@
+module Xero
+  class Api
+    OAUTH1_BASE            = 'https://api.xero.com/oauth'
+    OAUTH1_UNAUTHORIZED    = OAUTH1_BASE + '/RequestToken'
+    OAUTH1_REDIRECT        = OAUTH1_BASE + '/Authorize'
+    OAUTH1_ACCESS_TOKEN    = OAUTH1_BASE + '/AccessToken'
+
+    attr_accessor :token, :token_secret
+    attr_accessor :consumer_key, :consumer_secret
+
+    module Connection::OAuth1
+
+      def self.included(*)
+        Xero::Api::Connection.add_authorization_middleware :oauth1
+        super
+      end
+
+      def default_attributes
+        super.merge!(
+          token: nil, token_secret: nil,
+          consumer_key: defined?(CONSUMER_KEY) ? CONSUMER_KEY : nil,
+          consumer_secret: defined?(CONSUMER_SECRET) ? CONSUMER_SECRET : nil,
+        )
+      end
+
+      def add_oauth1_authorization_middleware(conn)
+        gem 'simple_oauth'
+        require 'simple_oauth'
+        conn.request :oauth, oauth_data
+      end
+
+      def use_oauth1_middleware?
+        token != nil
+      end
+
+      private
+
+      # Use with simple_oauth OAuth1 middleware
+      # @see #add_authorization_middleware
+      def oauth_data
+        {
+          consumer_key: @consumer_key,
+          consumer_secret: @consumer_secret,
+          token: @token,
+          token_secret: @token_secret
+        }
+      end
+
+    end
+  end
+end

data/lib/xero/api/connection/oauth2.rb

@@ -0,0 +1,24 @@
+class Xero::Api
+  attr_accessor :access_token
+
+  module Connection::OAuth2
+
+    def self.included(*)
+      Xero::Api::Connection.add_authorization_middleware :oauth2
+      super
+    end
+
+    def default_attributes
+      super.merge!(
+        access_token: nil
+      )
+    end
+    def add_oauth2_authorization_middleware(conn)
+      conn.request :oauth2, access_token, token_type: 'bearer'
+    end
+
+    def use_oauth2_middleware?
+      access_token != nil
+    end
+  end
+end

data/lib/xero/api/error.rb

@@ -0,0 +1,33 @@
+
+class Xero::Api
+  class Error < StandardError
+    attr_reader :fault
+    def initialize(errors = nil)
+      if errors
+        @fault = errors
+        super(errors)
+      end
+    end
+  end
+
+  # Raised on HTTP status code 400
+  class BadRequest < Error; end
+
+  # Raised on HTTP status code 401
+  class Unauthorized < Error; end
+
+  # Raised on HTTP status code 404
+  class NotFound < Error; end
+
+  # Raised on HTTP status code 412
+  class PreconditionFailed < Error; end
+
+  # Raised on HTTP status code 500
+  class InternalError < Error; end
+  
+  # Raised on HTTP status code 501
+  class NotImplemented < Error; end
+
+  # Raised on HTTP status code 503
+  class ServiceUnavailable < Error; end
+end

data/lib/xero/api/methods.rb

@@ -0,0 +1,67 @@
+class Xero::Api
+  module Methods
+
+    def get(entity, all: false, id: nil, params: nil, headers: nil, path: nil, modified_since: nil, parse_entity: true)
+      route = build_resource(entity, id: id, params: params, path: path)
+      final_headers = handle_headers(headers, modified_since)
+      if all
+        enumerator = get_all(entity, path: route, headers: final_headers, parse_entity: parse_entity)
+      else
+        request(:get, path: route, entity: entity, headers: final_headers, parse_entity: parse_entity)
+      end
+    end
+
+    def create(entity, payload:, params: nil, path: nil)
+      route = build_resource(entity, params: params, path: path)
+      request(:put, path: route, entity: entity, payload: payload)
+    end
+
+    def update(entity, id:, payload:, params: nil, path: nil)
+      route = build_resource(entity, id: id, params: params, path: path)
+      payload.merge!({ "Id": id })
+      request(:post, path: route, entity: entity, payload: payload)
+    end
+
+    def delete(entity, id:, params: nil, path: nil)
+      route = build_resource(entity, id: id, path: path)
+      request(:delete, path: route, entity: entity)
+    end
+
+    private
+
+    def build_resource(entity, id: nil, params: nil, path: nil)
+      route = entity_handler(entity)
+      route = "#{route}/#{id}" if id
+      route = "#{route}/#{path}" if path
+      route = add_params(route: route, params: params) if params
+      route
+    end
+
+    def handle_headers(headers, modified_since)
+      h = {}
+      h.merge!(headers) if headers
+      h.merge!(if_modified_hash(modified_since)) if modified_since
+      h
+    end
+
+    def if_modified_hash(modified_since)
+      { 'If-Modified-Since' => standard_date(modified_since) }
+    end
+
+    def get_all(entity, path:, headers:, parse_entity:)
+      max = 100
+      Enumerator.new do |enum_yielder|
+        number = 0
+        begin
+          number += 1
+          paged_path = add_params(route: path, params: { page: number })
+          results = request(:get, path: paged_path, entity: entity, headers: headers, parse_entity: parse_entity)
+          results.each do |result|
+            enum_yielder.yield(result)
+          end if results
+        end while (results ? results.size == max : false)
+      end
+    end
+
+  end
+end

data/lib/xero/api/raise_http_exception.rb

@@ -0,0 +1,42 @@
+require 'faraday'
+
+# @private
+module FaradayMiddleware
+  # @private
+  class RaiseHttpException < Faraday::Middleware
+    def call(env)
+      @app.call(env).on_complete do |response|
+        case response.status
+        when 200
+        when 204
+        when 400
+          raise Xero::Api::BadRequest.new(error_message(response))
+        when 401
+          raise Xero::Api::Unauthorized.new(error_message(response))
+        when 404
+          raise Xero::Api::NotFound.new(error_message(response))
+        when 412
+          raise Xero::Api::PreconditionFailed.new(error_message(response))
+        when 500
+          raise Xero::Api::InternalError.new(error_message(response))
+        when 501
+          raise Xero::Api::NotImplemented.new(error_message(response))
+        when 503
+          raise Xero::Api::ServiceUnavailable.new(error_message(response))
+        end
+      end
+    end
+
+    def initialize(app)
+      super app
+    end
+
+    private
+
+    def error_message(response)
+      error = ::JSON.parse(response.body)
+    rescue => e
+      response.body
+    end
+  end
+end

data/lib/xero/api/util.rb

@@ -0,0 +1,54 @@
+class Xero::Api
+  module Util
+
+    def add_params(route:, params:)
+      uri = URI.parse(route)
+      params.each do |p|
+        new_query_ar = URI.decode_www_form(uri.query || '') << p.to_a
+        uri.query = URI.encode_www_form(new_query_ar)
+      end
+      uri.to_s
+    end
+
+    def standard_date(date)
+      date.strftime('%Y-%m-%dT%H:%M:%S')
+    rescue => e
+      raise Xero::Api::Error, date_method_error_msg(e)
+    end
+
+    def json_date(date)
+      date.strftime("/Date(%s%L)/")
+    rescue => e 
+      raise Xero::Api::Error, date_method_error_msg(e)
+    end
+
+    def parse_json_date(datestring)
+      seconds_since_epoch = datestring.scan(/[0-9]+/)[0].to_i / 1000.0
+      Time.at(seconds_since_epoch)
+    end
+
+    def entity_handler(entity)
+      if entity.is_a?(Symbol)
+        snake_to_camel(entity)
+      else
+        entity
+      end
+    end
+
+    def snake_to_camel(sym)
+      sym.to_s.split('_').collect(&:capitalize).join
+    end
+
+    private 
+    
+    def date_method_error_msg(e)
+      if e.message =~ /undefined method \`strftime/
+        "The argument needs to be an instance of Date|Time|DateTime"
+      else
+        e.message
+      end
+    end
+
+  end
+end
+

data/lib/xero/api/version.rb

@@ -0,0 +1,5 @@
+module Xero
+  class Api
+    VERSION = "1.0.0"
+  end
+end

data/xero-api.gemspec

@@ -0,0 +1,33 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'xero/api/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "xero-api"
+  spec.version       = Xero::Api::VERSION
+  spec.authors       = ["Christian Pelczarski"]
+  spec.email         = ["christian@minimul.com"]
+
+  spec.summary       = %q{Ruby JSON-only client for Xero API. }
+  spec.homepage      = "https://github.com/minimul/xero-api"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.10"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency 'webmock'
+  spec.add_development_dependency 'faker'
+  spec.add_development_dependency 'simple_oauth'
+  spec.add_development_dependency 'dotenv'
+  spec.add_development_dependency 'vcr'
+  spec.add_development_dependency 'awesome_print'
+  spec.add_runtime_dependency 'faraday'
+  spec.add_runtime_dependency 'faraday_middleware'
+  spec.add_runtime_dependency 'faraday-detailed_logger'
+end

metadata

@@ -0,0 +1,240 @@
+--- !ruby/object:Gem::Specification
+name: xero-api
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Christian Pelczarski
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-10-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: faker
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simple_oauth
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: dotenv
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: vcr
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: awesome_print
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: faraday_middleware
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: faraday-detailed_logger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- christian@minimul.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".env.example_app.oauth1"
+- ".env.example_app.oauth2"
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- example/base.rb
+- example/oauth.rb
+- example/public/connect_xero_button_blue_2x.png
+- example/views/callback.erb
+- example/views/customers.erb
+- example/views/index.erb
+- lib/xero/api.rb
+- lib/xero/api/attachment.rb
+- lib/xero/api/configuration.rb
+- lib/xero/api/connection.rb
+- lib/xero/api/connection/oauth1.rb
+- lib/xero/api/connection/oauth2.rb
+- lib/xero/api/error.rb
+- lib/xero/api/methods.rb
+- lib/xero/api/raise_http_exception.rb
+- lib/xero/api/util.rb
+- lib/xero/api/version.rb
+- xero-api.gemspec
+homepage: https://github.com/minimul/xero-api
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.7
+signing_key: 
+specification_version: 4
+summary: Ruby JSON-only client for Xero API.
+test_files: []