taxamo 1.0.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8cf5f76565fff95a1fbae895d217fa71bb049be4
+  data.tar.gz: 23aaffe3c9121060f3491dcf3ece72fce0d645af
+SHA512:
+  metadata.gz: caa975d864fc42417e2d14109f6d2bfba405757f32590139d0b6efc00ffce06d416cce563c7a1922f6d99c256e574ba507ec652c232d077748fee1e527c45c2e
+  data.tar.gz: 3cfc7cd62e1e281a74df0450a48852ed631c470520863a9f1746660bf4c196df94ed3700ad59e926d1a476472a28f23f487718f60f81b269f2aab605a536d63e

data/Gemfile

@@ -0,0 +1,7 @@
+source "https://rubygems.org"
+gemspec
+
+if Gem::Version.new(RUBY_VERSION.dup) < Gem::Version.new('1.9.3')
+  gem 'rest-client', '~> 1.6.8'
+  gem 'activesupport', '~> 3.2'
+end

data/LICENSE

@@ -0,0 +1,11 @@
+Copyright 2014-2015 Taxamo, Ltd.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at [apache.org/licenses/LICENSE-2.0](http://www.apache.org/licenses/LICENSE-2.0)
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/README.md

@@ -0,0 +1,120 @@
+# Taxamo API Ruby client
+
+This package provides [Taxamo](http://www.taxamo.com) API bindings for Ruby and was generated using Swagger-codegen.
+
+## Installation
+
+To install it, just fetch this repository and issue the following command:
+
+```shell
+$ gem build taxamo.gemspec
+$ gem install taxamo-1.0.4.gem
+```
+
+Alternatively, add the following line to your project's `Gemfile` file:
+
+```ruby
+gem "taxamo", github: "taxamo/taxamo-ruby"
+```
+
+## Changes
+
+1.0.5 (2015-07-02):
+ * sync with the newest API model, including addition of getsettlementdailystats operation
+ 
+1.0.4 (2015-04-15):
+ * sync with the newest API data model, including unconfirm transaction and email invoice operations and a default currency code for each country
+ * please note, that the list_transactions operation has new argument: invoice_number, changing the argument count to 12
+
+1.0.3 (2015-04-15):
+ * use require_rel to make the require work properly when using bundler to manage the dependencies 
+ 
+1.0.2 (2015-03-16):
+ * Refresh CreateRefundOut with new field and updated documentation 
+ 
+1.0.1:
+ 
+ * Added buyer_tax_number_valid field to tax calculation, transaction storage and VAT number validation operations
+ * Added key_or_custom_id to list_transactions operation - please note, that the number of arguments has changed!
+
+## Usage
+
+First of all, you need to set your private test or live token:
+
+```ruby
+require 'taxamo'
+
+Swagger.configure do |config|
+  config.api_key = 'YOUR_TOKEN_HERE'
+end
+```
+
+Next, you can invoke the API as functions in Taxamo module:
+
+```ruby
+resp = Taxamo.get_transaction('SOME_TRANSACTION_ID')
+```
+
+It is possible to use hashes and arrays as input:
+
+```ruby
+resp = Taxamo.calculate_tax(
+        {'transaction' => {
+            'currency_code' => 'USD',
+            'buyer_ip' => '127.0.0.1',
+            'billing_country_code' => 'IE',
+            'force_country_code' => 'FR',
+            'transaction_lines' => [{'amount' => 200,
+                                     'custom_id' => 'line1'},
+                                    {'amount' => 100,
+                                     'product_type' => 'e-book',
+                                     'custom_id' => 'line2'}]}})
+```
+
+But also regular classes:
+
+```ruby
+taxIn = CalculateTaxIn.new
+taxIn.transaction = InputTransaction.new
+taxIn.transaction.currency_code = 'USD'
+taxIn.transaction.buyer_ip = '127.0.0.1'
+taxIn.transaction.billing_country_code = 'IE'
+taxIn.transaction.force_country_code = 'FR'
+taxIn.transaction.transaction_lines = [InputTransactionLine.new, InputTransactionLine.new]
+taxIn.transaction.transaction_lines[0].amount = 200
+taxIn.transaction.transaction_lines[0].custom_id = 'line1'
+taxIn.transaction.transaction_lines[1].amount = 100
+taxIn.transaction.transaction_lines[1].custom_id = 'line2'
+taxIn.transaction.transaction_lines[1].product_type = 'e-book'
+
+resp = Taxamo.calculate_tax(taxIn)
+```
+
+The output is always coerced to appropriate classes:
+
+```ruby
+assert_equal resp.transaction.countries.detected.code, 'IE'
+assert_equal resp.transaction.amount, 300
+assert_equal resp.transaction.tax_amount, 45.5
+assert_equal resp.transaction.total_amount, 345.5
+```
+
+See the regression tests for more examples.
+
+## Documentation
+
+Please see http://www.taxamo.com/documentation/ for the most up-to-date documentation.
+
+## License
+
+Copyright 2014-2015 Taxamo, Ltd.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at [apache.org/licenses/LICENSE-2.0](http://www.apache.org/licenses/LICENSE-2.0)
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/Rakefile

@@ -0,0 +1,7 @@
+require 'rake/testtask'
+
+task :default => [:test]
+
+Rake::TestTask.new do |t|
+  t.pattern = './test/**/*_test.rb'
+end

data/lib/monkey.rb

@@ -0,0 +1,90 @@
+# module Swagger
+  class Object 
+  
+    unless Object.method_defined? :blank?
+      def blank?
+        respond_to?(:empty?) ? empty? : !self
+      end
+    end
+  
+    unless Object.method_defined? :present?
+      def present?
+        !blank?
+      end
+    end
+
+  end
+
+  class String
+
+    unless String.method_defined? :underscore
+      def underscore
+        self.gsub(/::/, '/').
+        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+        gsub(/([a-z\d])([A-Z])/,'\1_\2').
+        tr("-", "_").
+        downcase
+      end
+    end
+  
+    unless String.method_defined? :camelize
+      def camelize(first_letter_in_uppercase = true)
+        if first_letter_in_uppercase != :lower
+          self.to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
+        else
+          self.to_s[0].chr.downcase + camelize(self)[1..-1]
+        end
+      end
+    end
+
+  end
+
+  class Hash
+
+    unless Hash.method_defined? :stringify_keys    
+      def stringify_keys
+        inject({}) do |options, (key, value)|
+          options[key.to_s] = value
+          options
+        end
+      end
+    end
+    
+    unless Hash.method_defined? :stringify_keys!
+      def stringify_keys!
+        self.replace(self.stringify_keys)
+      end
+    end
+
+    unless Hash.method_defined? :symbolize_keys
+      def symbolize_keys
+        inject({}) do |options, (key, value)|
+          options[(key.to_sym rescue key) || key] = value
+          options
+        end
+      end
+    end
+  
+    unless Hash.method_defined? :symbolize_keys!
+      def symbolize_keys!
+        self.replace(self.symbolize_keys)
+      end
+    end
+
+    unless Hash.method_defined? :symbolize_and_underscore_keys
+      def symbolize_and_underscore_keys
+        inject({}) do |options, (key, value)|
+          options[(key.to_s.underscore.to_sym rescue key) || key] = value
+          options
+        end
+      end
+    end
+
+    unless Hash.method_defined? :symbolize_and_underscore_keys!
+      def symbolize_and_underscore_keys!
+        self.replace(self.symbolize_and_underscore_keys)
+      end
+    end
+  
+  end
+# end

data/lib/swagger.rb

@@ -0,0 +1,93 @@
+require 'monkey'
+require 'swagger/configuration'
+require 'swagger/request'
+require 'swagger/response'
+require 'logger'
+
+module Swagger
+    
+  class << self
+    attr_accessor :logger
+    
+    # A Swagger configuration object. Must act like a hash and return sensible
+    # values for all Swagger configuration options. See Swagger::Configuration.
+    attr_accessor :configuration
+
+    attr_accessor :resources
+    
+    # Call this method to modify defaults in your initializers.
+    #
+    # @example
+    #   Swagger.configure do |config|
+    #     config.api_key = '1234567890abcdef'     # required
+    #     config.username = 'wordlover'           # optional, but needed for user-related functions
+    #     config.password = 'i<3words'            # optional, but needed for user-related functions
+    #     config.format = 'json'                  # optional, defaults to 'json'
+    #   end
+    #
+    def configure
+      self.configuration ||= Configuration.new
+      yield(configuration) if block_given?
+
+      # Configure logger.  Default to use Rails
+      self.logger ||= configuration.logger || (defined?(Rails) ? Rails.logger : Logger.new(STDOUT))
+
+      # remove :// from scheme
+      configuration.scheme.sub!(/:\/\//, '')
+
+      # remove http(s):// and anything after a slash
+      configuration.host.sub!(/https?:\/\//, '')
+      configuration.host = configuration.host.split('/').first
+
+      # Add leading and trailing slashes to base_path
+      configuration.base_path = "/#{configuration.base_path}".gsub(/\/+/, '/')
+      configuration.base_path = "" if configuration.base_path == "/"
+    end
+    
+    def authenticated?
+      Swagger.configuration.auth_token.present?
+    end
+    
+    def de_authenticate
+      Swagger.configuration.auth_token = nil
+    end
+    
+    def authenticate
+      return if Swagger.authenticated?
+      
+      if Swagger.configuration.username.blank? || Swagger.configuration.password.blank?
+        raise ClientError, "Username and password are required to authenticate."
+      end
+      
+      request = Swagger::Request.new(
+        :get, 
+        "account/authenticate/{username}", 
+        :params => {
+          :username => Swagger.configuration.username, 
+          :password => Swagger.configuration.password
+        }
+      )
+      
+      response_body = request.response.body
+      Swagger.configuration.auth_token = response_body['token']
+    end
+
+  end
+  
+end
+
+class ServerError < StandardError
+end
+
+class ValidationError < StandardError
+    attr_accessor :validation_failures
+end
+
+class NotFoundError < StandardError
+end
+
+class AuthenticationError < StandardError
+end
+
+class ClientError < StandardError
+end

data/lib/swagger/configuration.rb

@@ -0,0 +1,21 @@
+module Swagger
+
+  class Configuration
+
+    attr_accessor :format, :api_key, :username, :password, :auth_token, :scheme, :host, :base_path, :user_agent, :logger, :inject_format, :force_ending_format, :camelize_params
+    
+    # Defaults go in here..
+    def initialize
+      @format = 'json'
+      @scheme = 'https'
+      @host = 'api.taxamo.com'
+      @base_path = ''
+      @user_agent = "ruby-swagger"
+      @inject_format = true
+      @force_ending_format = false
+      @camelize_params = false
+    end
+
+  end
+
+end

data/lib/swagger/request.rb

@@ -0,0 +1,198 @@
+module Swagger
+
+  class Request
+    require 'uri'
+    require 'addressable/uri'
+    require 'typhoeus'
+
+    attr_accessor :host, :path, :format, :params, :body, :http_method, :headers
+
+
+    # All requests must have an HTTP method and a path
+    # Optionals parameters are :params, :headers, :body, :format, :host
+    # 
+    def initialize(http_method, path, attributes={})
+      attributes[:format] ||= Swagger.configuration.format
+      attributes[:params] ||= {}
+
+      # Set default headers
+      default_headers = {
+        'Content-Type' => "application/#{attributes[:format].downcase}",
+        'Token' => Swagger.configuration.api_key
+      }
+
+      # api_key from headers hash trumps the default, even if its value is blank
+      if attributes[:headers].present? && attributes[:headers].has_key?(:api_key)
+        default_headers.delete(:api_key)
+      end
+      
+      # api_key from params hash trumps all others (headers and default_headers)
+      if attributes[:params].present? && attributes[:params].has_key?(:api_key)
+        default_headers.delete(:api_key)
+        attributes[:headers].delete(:api_key) if attributes[:headers].present?
+      end
+      
+      # Merge argument headers into defaults
+      attributes[:headers] = default_headers.merge(attributes[:headers] || {})
+      
+      # Stick in the auth token if there is one
+      if Swagger.authenticated?
+        attributes[:headers].merge!({:auth_token => Swagger.configuration.auth_token})
+      end
+
+      self.http_method = http_method.to_sym
+      self.path = path
+      attributes.each do |name, value|
+        send("#{name.to_s.underscore.to_sym}=", value)
+      end
+    end
+
+    # Construct a base URL
+    #
+    def url(options = {})  
+      u = Addressable::URI.new(
+        :scheme => Swagger.configuration.scheme,
+        :host => Swagger.configuration.host,
+        :path => self.interpreted_path,
+        :query => self.query_string.sub(/\?/, '')
+      ).to_s
+      
+      # Drop trailing question mark, if present
+      u.sub! /\?$/, ''
+      
+      # Obfuscate API key?
+      u.sub! /api\_key=\w+/, 'api_key=YOUR_API_KEY' if options[:obfuscated]
+      
+      u
+    end
+
+    # Iterate over the params hash, injecting any path values into the path string
+    #
+    # e.g. /word.{format}/{word}/entries => /word.json/cat/entries
+    def interpreted_path
+      p = self.path.dup
+
+      # Fill in the path params
+      self.params.each_pair do |key, value|
+        p = p.gsub("{#{key}}", value.to_s)
+      end
+
+      # # Stick a .{format} placeholder into the path if there isn't
+      # # one already or an actual format like json or xml
+      # # e.g. /words/blah => /words.{format}/blah
+      # if Swagger.configuration.inject_format
+      #   unless ['.json', '.xml', '{format}'].any? {|s| p.downcase.include? s }
+      #     p = p.sub(/^(\/?\w+)/, "\\1.#{format}")
+      #   end
+      # end
+      #
+      # # Stick a .{format} placeholder on the end of the path if there isn't
+      # # one already or an actual format like json or xml
+      # # e.g. /words/blah => /words/blah.{format}
+      # if Swagger.configuration.force_ending_format
+      #   unless ['.json', '.xml', '{format}'].any? {|s| p.downcase.include? s }
+      #     p = "#{p}.#{format}"
+      #   end
+      # end
+      #
+      # p = p.sub("{format}", self.format.to_s)
+      #
+      URI.encode [Swagger.configuration.base_path, p].join("/").gsub(/\/+/, '/')
+    end
+  
+    # Massage the request body into a state of readiness
+    # If body is a hash, camelize all keys then convert to a json string
+    #
+    def body=(value)      
+      if value.is_a?(Hash)
+        value = value.inject({}) do |memo, (k,v)|
+          memo[k.to_s.camelize(:lower).to_sym] = v
+          memo
+        end
+      end
+      @body = value
+    end
+    
+    # If body is an object, JSONify it before making the actual request.
+    # 
+    def outgoing_body
+      body.is_a?(String) ? body : body.to_json
+    end
+    
+    # Construct a query string from the query-string-type params
+    def query_string
+
+      # Iterate over all params,
+      # .. removing the ones that are part of the path itself.
+      # .. stringifying values so Addressable doesn't blow up.
+      query_values = {}
+      self.params.each_pair do |key, value|
+        next if self.path.include? "{#{key}}"                                   # skip path params
+        next if value.blank? && value.class != FalseClass                       # skip empties
+        if Swagger.configuration.camelize_params
+          key = key.to_s.camelize(:lower).to_sym unless key.to_sym == :api_key    # api_key is not a camelCased param
+        end
+        query_values[key.to_s] = value.to_s
+      end
+    
+      # We don't want to end up with '?' as our query string
+      # if there aren't really any params
+      return "" if query_values.blank?
+    
+      # Addressable requires query_values to be set after initialization..
+      qs = Addressable::URI.new
+      qs.query_values = query_values
+      qs.to_s
+    end
+  
+    def make
+      logger = Logger.new STDOUT
+      logger.debug self.url
+      response = case self.http_method.to_sym
+      when :get,:GET
+        Typhoeus::Request.get(
+          self.url,
+          :headers => self.headers.stringify_keys,
+        )
+
+      when :post,:POST
+        Typhoeus::Request.post(
+          self.url,
+          :body => self.outgoing_body,
+          :headers => self.headers.stringify_keys,
+        )
+
+      when :put,:PUT
+        Typhoeus::Request.put(
+          self.url,
+          :body => self.outgoing_body,
+          :headers => self.headers.stringify_keys,
+        )
+      
+      when :delete,:DELETE
+        Typhoeus::Request.delete(
+          self.url,
+          :body => self.outgoing_body,
+          :headers => self.headers.stringify_keys,
+        )
+      end
+      Response.new(response)
+    end
+  
+    def response
+      self.make
+    end
+  
+    def response_code_pretty
+      return unless @response.present?
+      @response.code.to_s    
+    end
+  
+    def response_headers_pretty
+      return unless @response.present?
+      # JSON.pretty_generate(@response.headers).gsub(/\n/, '<br/>') # <- This was for RestClient
+      @response.headers.gsub(/\n/, '<br/>') # <- This is for Typhoeus
+    end
+
+  end
+end