flow-reference 0.2.85

data/lib/io_flow_reference_v0.rb

@@ -0,0 +1,1104 @@
+# Generated by apidoc - http://www.apidoc.me
+# Service version: 0.2.83
+# apidoc:0.11.76 http://www.apidoc.me/flow/reference/0.2.83/ruby_client
+
+require 'cgi'
+require 'net/http'
+require 'net/https'
+require 'uri'
+require 'base64'
+
+require 'date'
+require 'rubygems'
+require 'json'
+require 'bigdecimal'
+
+# Reference data that changes infrequently including countries, currencies,
+# languages, etc.
+module Io
+  module Flow
+    module Reference
+      module V0
+
+        class Client
+
+          module Constants
+
+            BASE_URL = 'https://api.flow.io/reference' unless defined?(Constants::BASE_URL)
+            NAMESPACE = 'io.flow.reference.v0' unless defined?(Constants::NAMESPACE)
+            USER_AGENT = 'apidoc:0.11.76 http://www.apidoc.me/flow/reference/0.2.83/ruby_client' unless defined?(Constants::USER_AGENT)
+            VERSION = '0.2.85' unless defined?(Constants::VERSION)
+            VERSION_MAJOR = 0 unless defined?(VERSION_MAJOR)
+
+          end
+
+          attr_reader :url
+
+          def initialize(url, opts={})
+            @url = HttpClient::Preconditions.assert_class('url', url, String)
+            @base_url = URI(url)
+            @authorization = HttpClient::Preconditions.assert_class_or_nil('authorization', opts.delete(:authorization), HttpClient::Authorization)
+            @default_headers = HttpClient::Preconditions.assert_class('default_headers', opts.delete(:default_headers) || {}, Hash)
+            @http_handler = opts.delete(:http_handler) || HttpClient::DefaultHttpHandler.new
+
+            HttpClient::Preconditions.assert_empty_opts(opts)
+            HttpClient::Preconditions.check_state(url.match(/http.+/i), "URL[%s] must start with http" % url)
+          end
+
+          # Creates an instance of the client using the base url specified in the API spec.
+          def Client.at_base_url(opts={})
+            Client.new(Constants::BASE_URL, opts)
+          end
+
+          def request(path=nil)
+            HttpClient::Preconditions.assert_class_or_nil('path', path, String)
+            request = HttpClient::Request.new(@http_handler, @base_url, path.to_s).with_header('User-Agent', Constants::USER_AGENT).with_header('X-Apidoc-Version', Constants::VERSION).with_header('X-Apidoc-Version-Major', Constants::VERSION_MAJOR)
+
+            @default_headers.each do |key, value|
+              request = request.with_header(key, value)
+            end
+
+            if @authorization
+              request = request.with_auth(@authorization)
+            end
+
+            request
+          end
+
+          def countries
+            @countries ||= ::Io::Flow::Reference::V0::Clients::Countries.new(self)
+          end
+
+          def currencies
+            @currencies ||= ::Io::Flow::Reference::V0::Clients::Currencies.new(self)
+          end
+
+          def languages
+            @languages ||= ::Io::Flow::Reference::V0::Clients::Languages.new(self)
+          end
+
+          def locales
+            @locales ||= ::Io::Flow::Reference::V0::Clients::Locales.new(self)
+          end
+
+          def regions
+            @regions ||= ::Io::Flow::Reference::V0::Clients::Regions.new(self)
+          end
+
+          def timezones
+            @timezones ||= ::Io::Flow::Reference::V0::Clients::Timezones.new(self)
+          end
+        end
+
+        module Clients
+
+          class Countries
+
+            def initialize(client)
+              @client = HttpClient::Preconditions.assert_class('client', client, ::Io::Flow::Reference::V0::Client)
+            end
+
+            # Returns a list of countries.
+            def get(incoming={})
+              opts = HttpClient::Helper.symbolize_keys(incoming)
+              query = {
+                :q => (x = opts.delete(:q); x.nil? ? nil : HttpClient::Preconditions.assert_class('q', x, String))
+              }.delete_if { |k, v| v.nil? }
+              r = @client.request("/reference/countries").with_query(query).get
+              r.map { |x| ::Io::Flow::Reference::V0::Models::Country.new(x) }
+            end
+
+          end
+
+          class Currencies
+
+            def initialize(client)
+              @client = HttpClient::Preconditions.assert_class('client', client, ::Io::Flow::Reference::V0::Client)
+            end
+
+            # Returns a list of currencies.
+            def get(incoming={})
+              opts = HttpClient::Helper.symbolize_keys(incoming)
+              query = {
+                :q => (x = opts.delete(:q); x.nil? ? nil : HttpClient::Preconditions.assert_class('q', x, String))
+              }.delete_if { |k, v| v.nil? }
+              r = @client.request("/reference/currencies").with_query(query).get
+              r.map { |x| ::Io::Flow::Reference::V0::Models::Currency.new(x) }
+            end
+
+          end
+
+          class Languages
+
+            def initialize(client)
+              @client = HttpClient::Preconditions.assert_class('client', client, ::Io::Flow::Reference::V0::Client)
+            end
+
+            # Returns a list of languages.
+            def get(incoming={})
+              opts = HttpClient::Helper.symbolize_keys(incoming)
+              query = {
+                :q => (x = opts.delete(:q); x.nil? ? nil : HttpClient::Preconditions.assert_class('q', x, String))
+              }.delete_if { |k, v| v.nil? }
+              r = @client.request("/reference/languages").with_query(query).get
+              r.map { |x| ::Io::Flow::Reference::V0::Models::Language.new(x) }
+            end
+
+          end
+
+          class Locales
+
+            def initialize(client)
+              @client = HttpClient::Preconditions.assert_class('client', client, ::Io::Flow::Reference::V0::Client)
+            end
+
+            # Returns a list of locales.
+            def get(incoming={})
+              opts = HttpClient::Helper.symbolize_keys(incoming)
+              query = {
+                :q => (x = opts.delete(:q); x.nil? ? nil : HttpClient::Preconditions.assert_class('q', x, String))
+              }.delete_if { |k, v| v.nil? }
+              r = @client.request("/reference/locales").with_query(query).get
+              r.map { |x| ::Io::Flow::Reference::V0::Models::Locale.new(x) }
+            end
+
+            # Returns the locale with the specifed id.
+            def get_by_id(id)
+              HttpClient::Preconditions.assert_class('id', id, String)
+              r = @client.request("/reference/locales/#{CGI.escape(id)}").get
+              ::Io::Flow::Reference::V0::Models::Locale.new(r)
+            end
+
+          end
+
+          class Regions
+
+            def initialize(client)
+              @client = HttpClient::Preconditions.assert_class('client', client, ::Io::Flow::Reference::V0::Client)
+            end
+
+            # Returns a list of regions.
+            def get(incoming={})
+              opts = HttpClient::Helper.symbolize_keys(incoming)
+              query = {
+                :q => (x = opts.delete(:q); x.nil? ? nil : HttpClient::Preconditions.assert_class('q', x, String))
+              }.delete_if { |k, v| v.nil? }
+              r = @client.request("/reference/regions").with_query(query).get
+              r.map { |x| ::Io::Flow::Reference::V0::Models::Region.new(x) }
+            end
+
+            # Returns the region with the specifed id.
+            def get_by_id(id)
+              HttpClient::Preconditions.assert_class('id', id, String)
+              r = @client.request("/reference/regions/#{CGI.escape(id)}").get
+              ::Io::Flow::Reference::V0::Models::Region.new(r)
+            end
+
+          end
+
+          class Timezones
+
+            def initialize(client)
+              @client = HttpClient::Preconditions.assert_class('client', client, ::Io::Flow::Reference::V0::Client)
+            end
+
+            # Returns a list of timezones.
+            def get(incoming={})
+              opts = HttpClient::Helper.symbolize_keys(incoming)
+              query = {
+                :q => (x = opts.delete(:q); x.nil? ? nil : HttpClient::Preconditions.assert_class('q', x, String))
+              }.delete_if { |k, v| v.nil? }
+              r = @client.request("/reference/timezones").with_query(query).get
+              r.map { |x| ::Io::Flow::Reference::V0::Models::Timezone.new(x) }
+            end
+
+          end
+
+        end
+
+        module Models
+
+          class PaymentMethodType
+
+            attr_reader :value
+
+            def initialize(value)
+              @value = HttpClient::Preconditions.assert_class('value', value, String)
+            end
+
+            # Returns the instance of PaymentMethodType for this value, creating a new instance for an unknown value
+            def PaymentMethodType.apply(value)
+              if value.instance_of?(PaymentMethodType)
+                value
+              else
+                HttpClient::Preconditions.assert_class_or_nil('value', value, String)
+                value.nil? ? nil : (from_string(value) || PaymentMethodType.new(value))
+              end
+            end
+
+            # Returns the instance of PaymentMethodType for this value, or nil if not found
+            def PaymentMethodType.from_string(value)
+              HttpClient::Preconditions.assert_class('value', value, String)
+              PaymentMethodType.ALL.find { |v| v.value == value }
+            end
+
+            def PaymentMethodType.ALL
+              @@all ||= [PaymentMethodType.card, PaymentMethodType.online, PaymentMethodType.offline]
+            end
+
+            # Represents all form of card payment (e.g. credit, debit, etc.)
+            def PaymentMethodType.card
+              @@_card ||= PaymentMethodType.new('card')
+            end
+
+            # Represents the most common form of alternative payment methods which require
+            # some degree of integration online (e.g. a redirect) to complete payment.
+            def PaymentMethodType.online
+              @@_online ||= PaymentMethodType.new('online')
+            end
+
+            # Offline payment method types represent payments like Cash On Delivery which
+            # require offline collection
+            def PaymentMethodType.offline
+              @@_offline ||= PaymentMethodType.new('offline')
+            end
+
+            def to_hash
+              value
+            end
+
+          end
+
+          # ISO 3166 country codes. Note Flow APIs will accept either the 2 or 3 character
+          # country code, but internally we normalize data and store as the 3 character,
+          # upper case ISO code. See https://api.flow.io/reference/countries
+          class Country
+
+            attr_reader :name, :iso_3166_2, :iso_3166_3, :languages, :measurement_system, :default_currency, :timezones, :default_delivered_duty
+
+            def initialize(incoming={})
+              opts = HttpClient::Helper.symbolize_keys(incoming)
+              HttpClient::Preconditions.require_keys(opts, [:name, :iso_3166_2, :iso_3166_3, :languages, :measurement_system, :timezones], 'Country')
+              @name = HttpClient::Preconditions.assert_class('name', opts.delete(:name), String)
+              @iso_3166_2 = HttpClient::Preconditions.assert_class('iso_3166_2', opts.delete(:iso_3166_2), String)
+              @iso_3166_3 = HttpClient::Preconditions.assert_class('iso_3166_3', opts.delete(:iso_3166_3), String)
+              @languages = HttpClient::Preconditions.assert_class('languages', opts.delete(:languages), Array).map { |v| HttpClient::Preconditions.assert_class('languages', v, String) }
+              @measurement_system = HttpClient::Preconditions.assert_class('measurement_system', opts.delete(:measurement_system), String)
+              @default_currency = (x = opts.delete(:default_currency); x.nil? ? nil : HttpClient::Preconditions.assert_class('default_currency', x, String))
+              @timezones = HttpClient::Preconditions.assert_class('timezones', opts.delete(:timezones), Array).map { |v| HttpClient::Preconditions.assert_class('timezones', v, String) }
+              @default_delivered_duty = (x = opts.delete(:default_delivered_duty); x.nil? ? nil : HttpClient::Preconditions.assert_class('default_delivered_duty', x, String))
+            end
+
+            def to_json
+              JSON.dump(to_hash)
+            end
+
+            def copy(incoming={})
+              Country.new(to_hash.merge(HttpClient::Helper.symbolize_keys(incoming)))
+            end
+
+            def to_hash
+              {
+                :name => name,
+                :iso_3166_2 => iso_3166_2,
+                :iso_3166_3 => iso_3166_3,
+                :languages => languages,
+                :measurement_system => measurement_system,
+                :default_currency => default_currency,
+                :timezones => timezones,
+                :default_delivered_duty => default_delivered_duty
+              }
+            end
+
+          end
+
+          # ISO 4217 3-character currency code. See
+          # https://api.flow.io/reference/currencies
+          class Currency
+
+            attr_reader :name, :iso_4217_3, :number_decimals, :symbols, :default_locale
+
+            def initialize(incoming={})
+              opts = HttpClient::Helper.symbolize_keys(incoming)
+              HttpClient::Preconditions.require_keys(opts, [:name, :iso_4217_3, :number_decimals], 'Currency')
+              @name = HttpClient::Preconditions.assert_class('name', opts.delete(:name), String)
+              @iso_4217_3 = HttpClient::Preconditions.assert_class('iso_4217_3', opts.delete(:iso_4217_3), String)
+              @number_decimals = HttpClient::Preconditions.assert_class('number_decimals', opts.delete(:number_decimals), Integer)
+              @symbols = (x = opts.delete(:symbols); x.nil? ? nil : (x = x; x.is_a?(::Io::Flow::Reference::V0::Models::CurrencySymbols) ? x : ::Io::Flow::Reference::V0::Models::CurrencySymbols.new(x)))
+              @default_locale = (x = opts.delete(:default_locale); x.nil? ? nil : HttpClient::Preconditions.assert_class('default_locale', x, String))
+            end
+
+            def to_json
+              JSON.dump(to_hash)
+            end
+
+            def copy(incoming={})
+              Currency.new(to_hash.merge(HttpClient::Helper.symbolize_keys(incoming)))
+            end
+
+            def to_hash
+              {
+                :name => name,
+                :iso_4217_3 => iso_4217_3,
+                :number_decimals => number_decimals,
+                :symbols => symbols.nil? ? nil : symbols.to_hash,
+                :default_locale => default_locale
+              }
+            end
+
+          end
+
+          # Defines one or more symbols representing this currency
+          class CurrencySymbols
+
+            attr_reader :primary, :narrow
+
+            def initialize(incoming={})
+              opts = HttpClient::Helper.symbolize_keys(incoming)
+              HttpClient::Preconditions.require_keys(opts, [:primary], 'CurrencySymbols')
+              @primary = HttpClient::Preconditions.assert_class('primary', opts.delete(:primary), String)
+              @narrow = (x = opts.delete(:narrow); x.nil? ? nil : HttpClient::Preconditions.assert_class('narrow', x, String))
+            end
+
+            def to_json
+              JSON.dump(to_hash)
+            end
+
+            def copy(incoming={})
+              CurrencySymbols.new(to_hash.merge(HttpClient::Helper.symbolize_keys(incoming)))
+            end
+
+            def to_hash
+              {
+                :primary => primary,
+                :narrow => narrow
+              }
+            end
+
+          end
+
+          # ISO 639 2-character language code. See https://api.flow.io/reference/languages
+          class Language
+
+            attr_reader :name, :iso_639_2
+
+            def initialize(incoming={})
+              opts = HttpClient::Helper.symbolize_keys(incoming)
+              HttpClient::Preconditions.require_keys(opts, [:name, :iso_639_2], 'Language')
+              @name = HttpClient::Preconditions.assert_class('name', opts.delete(:name), String)
+              @iso_639_2 = HttpClient::Preconditions.assert_class('iso_639_2', opts.delete(:iso_639_2), String)
+            end
+
+            def to_json
+              JSON.dump(to_hash)
+            end
+
+            def copy(incoming={})
+              Language.new(to_hash.merge(HttpClient::Helper.symbolize_keys(incoming)))
+            end
+
+            def to_hash
+              {
+                :name => name,
+                :iso_639_2 => iso_639_2
+              }
+            end
+
+          end
+
+          # Locales defines standard conventions for presentation of content. See
+          # https://api.flow.io/reference/locales
+          class Locale
+
+            attr_reader :id, :name, :country, :language, :numbers
+
+            def initialize(incoming={})
+              opts = HttpClient::Helper.symbolize_keys(incoming)
+              HttpClient::Preconditions.require_keys(opts, [:id, :name, :country, :language, :numbers], 'Locale')
+              @id = HttpClient::Preconditions.assert_class('id', opts.delete(:id), String)
+              @name = HttpClient::Preconditions.assert_class('name', opts.delete(:name), String)
+              @country = HttpClient::Preconditions.assert_class('country', opts.delete(:country), String)
+              @language = HttpClient::Preconditions.assert_class('language', opts.delete(:language), String)
+              @numbers = (x = opts.delete(:numbers); x.is_a?(::Io::Flow::Reference::V0::Models::LocaleNumbers) ? x : ::Io::Flow::Reference::V0::Models::LocaleNumbers.new(x))
+            end
+
+            def to_json
+              JSON.dump(to_hash)
+            end
+
+            def copy(incoming={})
+              Locale.new(to_hash.merge(HttpClient::Helper.symbolize_keys(incoming)))
+            end
+
+            def to_hash
+              {
+                :id => id,
+                :name => name,
+                :country => country,
+                :language => language,
+                :numbers => numbers.to_hash
+              }
+            end
+
+          end
+
+          # Number formats defined for a given locale
+          class LocaleNumbers
+
+            attr_reader :decimal, :group
+
+            def initialize(incoming={})
+              opts = HttpClient::Helper.symbolize_keys(incoming)
+              HttpClient::Preconditions.require_keys(opts, [:decimal, :group], 'LocaleNumbers')
+              @decimal = HttpClient::Preconditions.assert_class('decimal', opts.delete(:decimal), String)
+              @group = HttpClient::Preconditions.assert_class('group', opts.delete(:group), String)
+            end
+
+            def to_json
+              JSON.dump(to_hash)
+            end
+
+            def copy(incoming={})
+              LocaleNumbers.new(to_hash.merge(HttpClient::Helper.symbolize_keys(incoming)))
+            end
+
+            def to_hash
+              {
+                :decimal => decimal,
+                :group => group
+              }
+            end
+
+          end
+
+          # Represents a single payment method - e.g VISA or Paypal - and any associated
+          # metadata required for processing
+          class PaymentMethod
+
+            attr_reader :id, :type, :name, :images, :regions
+
+            def initialize(incoming={})
+              opts = HttpClient::Helper.symbolize_keys(incoming)
+              HttpClient::Preconditions.require_keys(opts, [:id, :type, :name, :images, :regions], 'PaymentMethod')
+              @id = HttpClient::Preconditions.assert_class('id', opts.delete(:id), String)
+              @type = (x = opts.delete(:type); x.is_a?(::Io::Flow::Reference::V0::Models::PaymentMethodType) ? x : ::Io::Flow::Reference::V0::Models::PaymentMethodType.apply(x))
+              @name = HttpClient::Preconditions.assert_class('name', opts.delete(:name), String)
+              @images = (x = opts.delete(:images); x.is_a?(::Io::Flow::Reference::V0::Models::PaymentMethodImages) ? x : ::Io::Flow::Reference::V0::Models::PaymentMethodImages.new(x))
+              @regions = HttpClient::Preconditions.assert_class('regions', opts.delete(:regions), Array).map { |v| HttpClient::Preconditions.assert_class('regions', v, String) }
+            end
+
+            def to_json
+              JSON.dump(to_hash)
+            end
+
+            def copy(incoming={})
+              PaymentMethod.new(to_hash.merge(HttpClient::Helper.symbolize_keys(incoming)))
+            end
+
+            def to_hash
+              {
+                :id => id,
+                :type => type.value,
+                :name => name,
+                :images => images.to_hash,
+                :regions => regions
+              }
+            end
+
+          end
+
+          class PaymentMethodImage
+
+            attr_reader :url, :width, :height
+
+            def initialize(incoming={})
+              opts = HttpClient::Helper.symbolize_keys(incoming)
+              HttpClient::Preconditions.require_keys(opts, [:url, :width, :height], 'PaymentMethodImage')
+              @url = HttpClient::Preconditions.assert_class('url', opts.delete(:url), String)
+              @width = HttpClient::Preconditions.assert_class('width', opts.delete(:width), Integer)
+              @height = HttpClient::Preconditions.assert_class('height', opts.delete(:height), Integer)
+            end
+
+            def to_json
+              JSON.dump(to_hash)
+            end
+
+            def copy(incoming={})
+              PaymentMethodImage.new(to_hash.merge(HttpClient::Helper.symbolize_keys(incoming)))
+            end
+
+            def to_hash
+              {
+                :url => url,
+                :width => width,
+                :height => height
+              }
+            end
+
+          end
+
+          class PaymentMethodImages
+
+            attr_reader :small, :medium, :large
+
+            def initialize(incoming={})
+              opts = HttpClient::Helper.symbolize_keys(incoming)
+              HttpClient::Preconditions.require_keys(opts, [:small, :medium, :large], 'PaymentMethodImages')
+              @small = (x = opts.delete(:small); x.is_a?(::Io::Flow::Reference::V0::Models::PaymentMethodImage) ? x : ::Io::Flow::Reference::V0::Models::PaymentMethodImage.new(x))
+              @medium = (x = opts.delete(:medium); x.is_a?(::Io::Flow::Reference::V0::Models::PaymentMethodImage) ? x : ::Io::Flow::Reference::V0::Models::PaymentMethodImage.new(x))
+              @large = (x = opts.delete(:large); x.is_a?(::Io::Flow::Reference::V0::Models::PaymentMethodImage) ? x : ::Io::Flow::Reference::V0::Models::PaymentMethodImage.new(x))
+            end
+
+            def to_json
+              JSON.dump(to_hash)
+            end
+
+            def copy(incoming={})
+              PaymentMethodImages.new(to_hash.merge(HttpClient::Helper.symbolize_keys(incoming)))
+            end
+
+            def to_hash
+              {
+                :small => small.to_hash,
+                :medium => medium.to_hash,
+                :large => large.to_hash
+              }
+            end
+
+          end
+
+          # A region represents a geographic area of the world. Regions can be countries,
+          # continents or other political areas (like the Eurozone). See
+          # https://api.flow.io/reference/regions
+          class Region
+
+            attr_reader :id, :name, :countries, :currencies, :languages, :measurement_systems, :timezones
+
+            def initialize(incoming={})
+              opts = HttpClient::Helper.symbolize_keys(incoming)
+              HttpClient::Preconditions.require_keys(opts, [:id, :name, :countries, :currencies, :languages, :measurement_systems, :timezones], 'Region')
+              @id = HttpClient::Preconditions.assert_class('id', opts.delete(:id), String)
+              @name = HttpClient::Preconditions.assert_class('name', opts.delete(:name), String)
+              @countries = HttpClient::Preconditions.assert_class('countries', opts.delete(:countries), Array).map { |v| HttpClient::Preconditions.assert_class('countries', v, String) }
+              @currencies = HttpClient::Preconditions.assert_class('currencies', opts.delete(:currencies), Array).map { |v| HttpClient::Preconditions.assert_class('currencies', v, String) }
+              @languages = HttpClient::Preconditions.assert_class('languages', opts.delete(:languages), Array).map { |v| HttpClient::Preconditions.assert_class('languages', v, String) }
+              @measurement_systems = HttpClient::Preconditions.assert_class('measurement_systems', opts.delete(:measurement_systems), Array).map { |v| HttpClient::Preconditions.assert_class('measurement_systems', v, String) }
+              @timezones = HttpClient::Preconditions.assert_class('timezones', opts.delete(:timezones), Array).map { |v| HttpClient::Preconditions.assert_class('timezones', v, String) }
+            end
+
+            def to_json
+              JSON.dump(to_hash)
+            end
+
+            def copy(incoming={})
+              Region.new(to_hash.merge(HttpClient::Helper.symbolize_keys(incoming)))
+            end
+
+            def to_hash
+              {
+                :id => id,
+                :name => name,
+                :countries => countries,
+                :currencies => currencies,
+                :languages => languages,
+                :measurement_systems => measurement_systems,
+                :timezones => timezones
+              }
+            end
+
+          end
+
+          # Time zone data is provided by the public IANA time zone database. See
+          # http://www.iana.org/time-zones
+          class Timezone
+
+            attr_reader :name, :description, :offset
+
+            def initialize(incoming={})
+              opts = HttpClient::Helper.symbolize_keys(incoming)
+              HttpClient::Preconditions.require_keys(opts, [:name, :description, :offset], 'Timezone')
+              @name = HttpClient::Preconditions.assert_class('name', opts.delete(:name), String)
+              @description = HttpClient::Preconditions.assert_class('description', opts.delete(:description), String)
+              @offset = HttpClient::Preconditions.assert_class('offset', opts.delete(:offset), Integer)
+            end
+
+            def to_json
+              JSON.dump(to_hash)
+            end
+
+            def copy(incoming={})
+              Timezone.new(to_hash.merge(HttpClient::Helper.symbolize_keys(incoming)))
+            end
+
+            def to_hash
+              {
+                :name => name,
+                :description => description,
+                :offset => offset
+              }
+            end
+
+          end
+
+        end
+
+        # ===== END OF SERVICE DEFINITION =====
+        module HttpClient
+
+          class HttpHandler
+
+            # Returns a client instance to use
+            #
+            # @param base_uri The base URI for this API
+            # @param path the Requested full http path (including any query strings)
+            def instance(base_uri, path)
+              raise "Override in subclass"
+            end
+
+          end
+
+          class HttpHandlerInstance
+
+            # Executes a request. The provided request object will be an
+            # instance of Net::HTTP (e.g. Net::HTTP::Get)
+            def execute(request)
+              raise "Override in subclass"
+            end
+
+          end
+
+          class DefaultHttpHandler < HttpHandler
+
+            def instance(base_uri, path)
+              DefaultHttpHandlerInstance.new(base_uri)
+            end
+
+          end
+
+          class DefaultHttpHandlerInstance < HttpHandlerInstance
+
+            attr_reader :client
+
+            def initialize(base_uri)
+              @base_uri = Preconditions.assert_class('base_uri', base_uri, URI)
+              @client = Net::HTTP.new(@base_uri.host, @base_uri.port)
+              if @base_uri.scheme == "https"
+                configure_ssl
+              end
+            end
+
+            def execute(request)
+              response = begin
+                           @client.request(request)
+                         rescue SocketError => e
+                           raise Exception.new("Error accessing uri[#{full_uri(request.path)}]: #{e}")
+                         end
+
+              case response
+              when Net::HTTPSuccess
+                response.body
+              else
+                body = response.body rescue nil
+                raise HttpClient::ServerError.new(response.code.to_i, response.message, :body => body, :uri => full_uri(request.path).to_s)
+              end
+            end
+
+            def full_uri(path)
+              File.join(@base_uri.to_s, path)
+            end
+
+            # Called to configure SSL if the base uri requires it
+            def configure_ssl
+              @client.use_ssl = true
+              @client.verify_mode = OpenSSL::SSL::VERIFY_PEER
+              @client.cert_store = OpenSSL::X509::Store.new
+              @client.cert_store.set_default_paths
+            end
+
+          end
+
+          class Request
+
+            attr_reader :path
+
+            def initialize(http_handler, base_uri, path)
+              @http_handler = http_handler
+              @base_uri = Preconditions.assert_class('base_uri', base_uri, URI)
+              @path = Preconditions.assert_class('path', path, String)
+              @params = nil
+              @body = nil
+              @auth = nil
+              @headers = {}
+              @header_keys_lower_case = []
+            end
+
+            def with_header(name, value)
+              Preconditions.check_not_blank('name', name, "Header name is required")
+              Preconditions.check_not_blank('value', value, "Header value is required")
+              Preconditions.check_state(!@headers.has_key?(name),
+                                        "Duplicate header named[%s]" % name)
+              @headers[name] = value
+              @header_keys_lower_case << name.downcase
+              self
+            end
+
+            def with_auth(auth)
+              Preconditions.assert_class('auth', auth, HttpClient::Authorization)
+              Preconditions.check_state(@auth.nil?, "auth previously set")
+
+              if auth.scheme.name == AuthScheme::BASIC.name
+                @auth = auth
+              else
+                raise "Auth Scheme[#{auth.scheme.name}] not supported"
+              end
+              self
+            end
+
+            def with_query(params)
+              Preconditions.assert_class('params', params, Hash)
+              Preconditions.check_state(@params.nil?, "Already have query parameters")
+              @params = params
+              self
+            end
+
+            # Wrapper to set Content-Type header to application/json and set
+            # the provided json document as the body
+            def with_json(json)
+              @headers['Content-Type'] ||= 'application/json; charset=UTF-8'
+              with_body(json)
+            end
+
+            def with_body(body)
+              Preconditions.check_not_blank('body', body)
+              @body = body
+              self
+            end
+
+            def get(&block)
+              do_request(Net::HTTP::Get, &block)
+            end
+
+            def delete(&block)
+              do_request(Net::HTTP::Delete, &block)
+            end
+
+            def options(&block)
+              do_request(Net::HTTP::Options, &block)
+            end
+
+            def post(&block)
+              do_request(Net::HTTP::Post, &block)
+            end
+
+            def put(&block)
+              do_request(Net::HTTP::Put, &block)
+            end
+
+            class PATCH < Net::HTTP::Put
+              METHOD = "PATCH"
+            end
+
+            def patch(&block)
+              do_request(PATCH, &block)
+            end
+
+            def do_request(klass)
+              Preconditions.assert_class('klass', klass, Class)
+
+              uri = path.dup
+              if q = to_query(@params)
+                uri += "?%s" % q
+              end
+
+              request = klass.send(:new, uri)
+
+              curl = ['curl']
+              if klass != Net::HTTP::Get
+                curl << "-X%s" % klass.name.split("::").last.upcase
+              end
+
+              if @body
+                # DEBUG path = "/tmp/rest_client.tmp"
+                # DEBUG File.open(path, "w") { |os| os << @body.to_s }
+                # DEBUG curl << "-d@%s" % path
+                request.body = @body
+              end
+
+              if @auth
+                curl << "-u \"%s:%s\"" % [@auth.username, @auth.password]
+                Preconditions.check_state(!@header_keys_lower_case.include?("authorization"),
+                                          "Cannot specify both an Authorization header and an auth instance")
+                user_pass = "%s:%s" % [@auth.username, @auth.password]
+                encoded = Base64.encode64(user_pass).to_s.split("\n").map(&:strip).join
+                request.add_field("Authorization", "Basic %s" % encoded)
+              end
+
+              @headers.each { |key, value|
+                curl <<  "-H \"%s: %s\"" % [key, value]
+                request.add_field(key, value)
+              }
+
+              curl << "'%s%s'" % [@base_uri, path]
+              # DEBUG puts curl.join(" ")
+
+              raw_response = @http_handler.instance(@base_uri, request.path).execute(request)
+              response = raw_response.to_s == "" ? nil : JSON.parse(raw_response)
+
+              if block_given?
+                yield response
+              else
+                response
+              end
+            end
+
+            private
+            def to_query(params={})
+              parts = (params || {}).map { |k,v|
+                if v.is_a?(Enumerable)
+                  v.map { |el| "%s=%s" % [k, CGI.escape(el.to_s)] }
+                else
+                  "%s=%s" % [k, CGI.escape(v.to_s)]
+                end
+              }
+              parts.empty? ? nil : parts.join("&")
+            end
+
+          end
+
+          class ServerError < StandardError
+
+            attr_reader :code, :details, :body, :uri
+
+            def initialize(code, details, incoming={})
+              opts = HttpClient::Helper.symbolize_keys(incoming)
+              @code = HttpClient::Preconditions.assert_class('code', code, Integer)
+              @details = HttpClient::Preconditions.assert_class('details', details, String)
+              @body = HttpClient::Preconditions.assert_class_or_nil('body', opts.delete(:body), String)
+              @uri = HttpClient::Preconditions.assert_class_or_nil('uri', opts.delete(:uri), String)
+              HttpClient::Preconditions.assert_empty_opts(opts)
+              super(self.message)
+            end
+
+            def message
+              m = "%s %s" % [@code, @details]
+              if @body
+                m << ": %s" % @body
+              end
+              m
+            end
+
+            def body_json
+              @body ? JSON.parse(@body) : nil
+            end
+
+          end
+
+          class PreconditionException < Exception
+
+            attr_reader :message
+
+            def initialize(message)
+              super(message)
+              @message = message
+            end
+
+          end
+
+          module Preconditions
+
+            def Preconditions.check_argument(expression, error_message=nil)
+              if !expression
+                raise PreconditionException.new(error_message || "check_argument failed")
+              end
+              nil
+            end
+
+            def Preconditions.check_state(expression, error_message=nil)
+              if !expression
+                raise PreconditionException.new(error_message || "check_state failed")
+              end
+              nil
+            end
+
+            def Preconditions.check_not_nil(field_name, reference, error_message=nil)
+              if reference.nil?
+                raise PreconditionException.new(error_message || "argument for %s cannot be nil" % field_name)
+              end
+              reference
+            end
+
+            def Preconditions.check_not_blank(field_name, reference, error_message=nil)
+              if reference.to_s.strip == ""
+                raise PreconditionException.new(error_message || "argument for %s cannot be blank" % field_name)
+              end
+              reference
+            end
+
+            # Throws an error if opts is not empty. Useful when parsing
+            # arguments to a function
+            def Preconditions.assert_empty_opts(opts)
+              if !opts.empty?
+                raise PreconditionException.new("Invalid opts: #{opts.keys.inspect}\n#{opts.inspect}")
+              end
+            end
+
+            # Requires that the provided hash has the specified keys.
+            # @param fields A list of symbols
+            def Preconditions.require_keys(hash, fields, error_prefix=nil)
+              missing = fields.select { |f| !hash.has_key?(f) }
+              if !missing.empty?
+                msg = "Missing required fields: " + missing.join(", ")
+                raise PreconditionException.new(error_prefix.empty? ? msg : "#{error_prefix}: #{msg}")
+              end
+            end
+
+            # Asserts that value is not nill and is_?(klass). Returns
+            # value. Common use is
+            #
+            # amount = Preconditions.assert_class('amount', amount, BigDecimal)
+            def Preconditions.assert_class(field_name, value, klass)
+              Preconditions.check_not_nil('field_name', field_name)
+              Preconditions.check_not_nil('klass', klass)
+              Preconditions.check_not_nil('value', value, "Value for %s cannot be nil. Expected an instance of class %s" % [field_name, klass.name])
+              Preconditions.check_state(value.is_a?(klass),
+                                        "Value for #{field_name} is of type[#{value.class}] - class[#{klass}] is required. value[#{value.inspect.to_s}]")
+              value
+            end
+
+            def Preconditions.assert_class_or_nil(field_name, value, klass)
+              if !value.nil?
+                Preconditions.assert_class(field_name, value, klass)
+              end
+            end
+
+            def Preconditions.assert_boolean(field_name, value)
+              Preconditions.check_not_nil('field_name', field_name)
+              Preconditions.check_not_nil('value', value, "Value for %s cannot be nil. Expected an instance of TrueClass or FalseClass" % field_name)
+              Preconditions.check_state(value.is_a?(TrueClass) || value.is_a?(FalseClass),
+                                        "Value for #{field_name} is of type[#{value.class}] - class[TrueClass or FalseClass] is required. value[#{value.inspect.to_s}]")
+              value
+            end
+
+            def Preconditions.assert_boolean_or_nil(field_name, value)
+              if !value.nil?
+                Preconditions.assert_boolean(field_name, value)
+              end
+            end
+
+            def Preconditions.assert_collection_of_class(field_name, values, klass)
+              Preconditions.assert_class(field_name, values, Array)
+              values.each { |v| Preconditions.assert_class(field_name, v, klass) }
+            end
+
+            def Preconditions.assert_hash_of_class(field_name, hash, klass)
+              Preconditions.assert_class(field_name, hash, Hash)
+              values.each { |k, v| Preconditions.assert_class(field_name, v, klass) }
+            end
+
+          end
+
+          class AuthScheme
+
+            attr_reader :name
+
+            def initialize(name)
+              @name = HttpClient::Preconditions.check_not_blank('name', name)
+            end
+
+            BASIC = AuthScheme.new("basic") unless defined?(BASIC)
+
+          end
+
+          class Authorization
+
+            attr_reader :scheme, :username, :password
+
+            def initialize(scheme, username, opts={})
+              @scheme = HttpClient::Preconditions.assert_class('schema', scheme, AuthScheme)
+              @username = HttpClient::Preconditions.check_not_blank('username', username, "username is required")
+              @password = HttpClient::Preconditions.assert_class_or_nil('password', opts.delete(:password), String)
+              HttpClient::Preconditions.assert_empty_opts(opts)
+            end
+
+            def Authorization.basic(username, password=nil)
+              Authorization.new(AuthScheme::BASIC, username, :password => password)
+            end
+
+          end
+
+          module Helper
+
+            def Helper.symbolize_keys(hash)
+              Preconditions.assert_class('hash', hash, Hash)
+              new_hash = {}
+              hash.each { |k, v|
+                new_hash[k.to_sym] = v
+              }
+              new_hash
+            end
+
+            def Helper.to_big_decimal(value)
+              value ? BigDecimal.new(value.to_s) : nil
+            end
+
+            def Helper.to_object(value)
+              value ? (value.is_a?(Hash) ? value : JSON.parse(value)) : nil
+            end
+
+            def Helper.to_uuid(value)
+              Preconditions.check_state(value.nil? || value.match(/^\w\w\w\w\w\w\w\w\-\w\w\w\w\-\w\w\w\w\-\w\w\w\w\-\w\w\w\w\w\w\w\w\w\w\w\w$/),
+                                        "Invalid guid[%s]" % value)
+              value
+            end
+
+            def Helper.to_date_iso8601(value)
+              if value.is_a?(Date)
+                value
+              elsif value
+                Date.parse(value.to_s)
+              else
+                nil
+              end
+            end
+
+            def Helper.to_date_time_iso8601(value)
+              if value.is_a?(DateTime)
+                value
+              elsif value
+                DateTime.parse(value.to_s)
+              else
+                nil
+              end
+            end
+
+            def Helper.date_iso8601_to_string(value)
+              value.nil? ? nil : value.strftime('%Y-%m-%d')
+            end
+
+            def Helper.date_time_iso8601_to_string(value)
+              value.nil? ? nil : value.strftime('%Y-%m-%dT%H:%M:%S%z')
+            end
+
+            TRUE_STRINGS = ['t', 'true', 'y', 'yes', 'on', '1', 'trueclass'] unless defined?(TRUE_STRINGS)
+            FALSE_STRINGS = ['f', 'false', 'n', 'no', 'off', '0', 'falseclass'] unless defined?(FALSE_STRINGS)
+
+            def Helper.to_boolean(field_name, value)
+              string = value.to_s.strip.downcase
+              if TRUE_STRINGS.include?(string)
+                true
+              elsif FALSE_STRINGS.include?(string)
+                false
+              elsif string != ""
+                raise PreconditionException.new("Unsupported boolean value[#{string}]. For true, must be one of: #{TRUE_STRINGS.inspect}. For false, must be one of: #{FALSE_STRINGS.inspect}")
+              else
+                nil
+              end
+            end
+
+          end
+
+        end
+      end
+    end
+  end
+end