fortnox-api 0.1.0 → 0.2.0

data/fortnox-api.gemspec

@@ -6,12 +6,12 @@ require 'fortnox/api/version'
 Gem::Specification.new do |spec|
   spec.name          = "fortnox-api"
   spec.version       = Fortnox::API::VERSION
-  spec.authors       = ["Jonas Schubert Erlandsson"]
+  spec.authors       = ["Jonas Schubert Erlandsson", "Hannes Elvemyr"]
   spec.email         = ["jonas.schubert.erlandsson@my-codeworks.com"]
   spec.summary       = "Gem to use Fortnox REST API in Ruby."
   spec.description   = "This gem uses the HTTParty library to abstract away the REST calls. It gives you access to a number of objects that behave a lot like ActiveRecord instances, giving you access to methods like `all`, `find`, `find_by_...` and so on. And each individual instance can be easaly persistable to Fortnox again using the `save` method."
   spec.homepage      = "http://github.com/my-codeworks/fortnox-api"
-  spec.license       = "MIT"
+  spec.license       = "LGPL-3.0"
 
   spec.files         = `git ls-files -z`.split("\x0")
   spec.executables   = spec.files.grep(%r{^bin/}){ |f| File.basename(f) }
@@ -20,17 +20,20 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency "httparty", "~> 0.13"
   spec.add_dependency "dotenv", "~> 2.0"
-  spec.add_dependency "virtus", "~> 1.0"
-  spec.add_dependency "vanguard", "~> 0.0"
+  spec.add_dependency "dry-struct", "~> 0.1"
+  spec.add_dependency "dry-types", "~> 0.8"
 
   spec.add_development_dependency "bundler", "~> 1.9"
   spec.add_development_dependency "rake", "~> 10.4"
   spec.add_development_dependency "rspec", "~> 3.2"
+  spec.add_development_dependency "rspec-collection_matchers", "~> 0"
   spec.add_development_dependency "guard", "~> 2.12"
   spec.add_development_dependency "guard-rspec", "~> 4.5"
   spec.add_development_dependency "webmock", "~> 1.21"
   spec.add_development_dependency "vcr", "~> 3.0"
-  spec.add_development_dependency "pry"
-  spec.add_development_dependency "codeclimate-test-reporter"
+  spec.add_development_dependency "pry", "~> 0"
+  spec.add_development_dependency "codeclimate-test-reporter", "~> 0"
+  spec.add_development_dependency "rubocop", "~> 0.41"
+  spec.add_development_dependency "rubocop-rspec", "~> 1.7"
 
 end

data/lib/fortnox/api.rb

@@ -1,28 +1,44 @@
 require "set"
 require "dotenv"
+require "dry-struct"
 require "fortnox/api/base"
 require "fortnox/api/version"
+require 'logger'
 
 Dotenv.load unless ENV['RUBY_ENV'] == 'test'
 
 module Fortnox
   module API
 
-    class RemoteServerError < ::RuntimeError
+    class Exception < StandardError
+    end
+
+    class AttributeError < Fortnox::API::Exception
+    end
+
+    class RemoteServerError < Fortnox::API::Exception
+    end
+
+    class MissingAttributeError < Fortnox::API::Exception
     end
 
     class << self
       @debugging = false
+      @logger = Logger.new(STDOUT)
       attr_accessor :debugging
+      attr_accessor :logger
+
+      @logger.level = Logger::WARN
     end
 
     def self.get_access_token
       Base.get_access_token
     end
 
+    Registry = Dry::Container.new
   end
 end
 
 require "fortnox/api/models"
 require "fortnox/api/repositories"
-require "fortnox/api/validators"
+require "fortnox/api/mappers"

data/lib/fortnox/api/base.rb

@@ -17,9 +17,9 @@ module Fortnox
       DEFAULT_HEADERS = {
         'Content-Type' => 'application/json',
         'Accept' => 'application/json',
-      }
+      }.freeze
 
-      HTTP_METHODS = [ :get, :put, :post, :delete ]
+      HTTP_METHODS = [ :get, :put, :post, :delete ].freeze
 
       attr_accessor :headers
 
@@ -28,12 +28,14 @@ module Fortnox
 
         self.headers = DEFAULT_HEADERS.merge({
           'Client-Secret' => get_client_secret,
-          'Access-Token' => get_access_token,
         })
+
+        check_access_tokens!
       end
 
       HTTP_METHODS.each do |method|
         define_method method do |*args|
+          self.headers['Access-Token'] = get_access_token
           execute do |remote|
             remote.send( method, *args )
           end

data/lib/fortnox/api/environment_validation.rb

@@ -1,33 +1,78 @@
+require 'forwardable'
+
 module Fortnox
   module API
     module EnvironmentValidation
 
+      class MissingEnvironmentVariable < ArgumentError
+      end
+
+      class CircularQueue
+        extend Forwardable
+
+        def initialize *items
+          @queue = [ *items ]
+          @@next_index = random_start_index
+        end
+
+        # support some general Array methods that fit Queues well
+        def_delegators :@queue, :new, :[], :size
+
+        def next
+          value = @queue[ @@next_index ]
+          if @@next_index == size - 1
+            @@next_index = 0
+          else
+            @@next_index += 1
+          end
+          return value
+        end
+
+        private
+
+          def random_start_index
+            Random.rand(@queue.size)
+          end
+      end
+
       private
 
         def get_base_url
           base_url = ENV['FORTNOX_API_BASE_URL']
-          fail ArgumentError, 'You have to provide a base url.' unless base_url
+          fail MissingEnvironmentVariable, 'You have to provide a base url.' unless base_url
           base_url
         end
 
         def get_client_secret
           client_secret = ENV['FORTNOX_API_CLIENT_SECRET']
-          fail ArgumentError, 'You have to provide your client secret.' unless client_secret
+          fail MissingEnvironmentVariable, 'You have to provide your client secret.' unless client_secret
           client_secret
         end
 
         def get_access_token
-          access_token = ENV['FORTNOX_API_ACCESS_TOKEN']
-          fail ArgumentError, 'You have to provide your access token.' unless access_token
-          access_token
+          @access_tokens ||= load_access_tokens
+          @access_tokens.next
         end
 
         def get_authorization_code
           authorization_code = ENV['FORTNOX_API_AUTHORIZATION_CODE']
-          fail ArgumentError, 'You have to provide your access token.' unless authorization_code
+          fail MissingEnvironmentVariable, 'You have to provide your authorization code.' unless authorization_code
           authorization_code
         end
 
+        def load_access_tokens
+          check_access_tokens!
+          access_token_string = ENV['FORTNOX_API_ACCESS_TOKEN']
+          access_tokens = access_token_string.split(",").map(&:strip)
+          CircularQueue.new( *access_tokens )
+        end
+
+        def check_access_tokens!
+          unless ENV['FORTNOX_API_ACCESS_TOKEN']
+            fail MissingEnvironmentVariable, 'You have to provide your access token.'
+          end
+        end
+
     end
   end
 end

data/lib/fortnox/api/mappers.rb

@@ -0,0 +1,49 @@
+require 'fortnox/api/types'
+
+module Fortnox
+  module API
+    module Mapper
+      Identity = ->(value){ value }
+
+      Date = ->(value){ value.to_s }
+
+      Array = ->(array) do
+        array.each_with_object( [] ) do |item, converted_array|
+          name = Fortnox::API::Mapper::Base.canonical_name_sym( item )
+          converted_array << Fortnox::API::Registry[ name ].call( item )
+        end
+      end
+
+      Registry.register( :fixnum, Fortnox::API::Mapper::Identity )
+      Registry.register( :int, Fortnox::API::Mapper::Identity )
+      Registry.register( :float, Fortnox::API::Mapper::Identity )
+      Registry.register( :string, Fortnox::API::Mapper::Identity )
+      Registry.register( :boolean, Fortnox::API::Mapper::Identity )
+      Registry.register( :falseclass, Fortnox::API::Mapper::Identity )
+      Registry.register( :trueclass, Fortnox::API::Mapper::Identity )
+      Registry.register( :nilclass, Fortnox::API::Mapper::Identity )
+      Registry.register( :array, Fortnox::API::Mapper::Array )
+      Registry.register( :date, Fortnox::API::Mapper::Date )
+
+      Registry.register( :account_number, Fortnox::API::Mapper::Identity )
+      Registry.register( :country_code, Fortnox::API::Mapper::Identity )
+      Registry.register( :currency, Fortnox::API::Mapper::Identity )
+      Registry.register( :customer_type, Fortnox::API::Mapper::Identity )
+      Registry.register( :discount_type, Fortnox::API::Mapper::Identity )
+      Registry.register( :email, Fortnox::API::Mapper::Identity )
+      Registry.register( :house_work_type, Fortnox::API::Mapper::Identity )
+      Registry.register( :vat_type, Fortnox::API::Mapper::Identity )
+      Registry.register( :labels, Fortnox::API::Mapper::Array )
+    end
+  end
+end
+
+require 'fortnox/api/mappers/customer'
+require 'fortnox/api/mappers/default_delivery_types'
+require 'fortnox/api/mappers/default_templates'
+require 'fortnox/api/mappers/edi_information'
+require 'fortnox/api/mappers/email_information'
+require 'fortnox/api/mappers/invoice_row'
+require 'fortnox/api/mappers/invoice'
+require 'fortnox/api/mappers/order_row'
+require 'fortnox/api/mappers/order'

data/lib/fortnox/api/mappers/base.rb

@@ -0,0 +1,47 @@
+require "fortnox/api/mappers/base/from_json"
+require "fortnox/api/mappers/base/to_json"
+
+module Fortnox
+  module API
+    module Mapper
+      class Base
+        include FromJSON
+        include ToJSON
+
+        Hash = ->(hash) do
+          hash.each do |key, value|
+            name = Fortnox::API::Mapper::Base.canonical_name_sym( value )
+            hash[key] = Fortnox::API::Registry[ name ].call( value )
+          end
+        end
+
+        Registry.register( :hash, Fortnox::API::Mapper::Base::Hash )
+
+        def self.canonical_name_sym( *values )
+          klass = if values.empty?
+                    self
+                  elsif values.first.is_a? Class
+                    values.first
+                  else
+                    values.first.class
+                  end
+
+          klass.name.split('::').last.downcase.to_sym
+        end
+
+        def diff( entity_hash, parent_hash )
+          hash_diff( entity_hash[self.class::JSON_ENTITY_WRAPPER],
+                     parent_hash[self.class::JSON_ENTITY_WRAPPER] )
+        end
+
+        private
+
+          def hash_diff( hash1, hash2 )
+            hash1.dup.
+              delete_if{ |k, v| hash2[k] == v }.
+              merge!(hash2.dup.delete_if{ |k, _| hash1.has_key?(k) })
+          end
+      end
+    end
+  end
+end

data/lib/fortnox/api/mappers/base/from_json.rb

@@ -0,0 +1,78 @@
+module Fortnox
+  module API
+    module Mapper
+      module FromJSON
+
+        class MissingModelOrMapperException < StandardError
+        end
+
+        def wrapped_json_collection_to_entities_hash( json_collection_hash )
+          entities_hash = []
+          json_collection_hash[ self.class::JSON_COLLECTION_WRAPPER ].each do |json_hash|
+            entities_hash << json_hash_to_entity_hash( json_hash, self.class::KEY_MAP )
+          end
+
+          entities_hash
+        end
+
+        def wrapped_json_hash_to_entity_hash( json_entity_hash )
+          json_hash_to_entity_hash( json_entity_hash[self.class::JSON_ENTITY_WRAPPER],
+                                   self.class::KEY_MAP )
+        end
+
+        private
+
+        def json_hash_to_entity_hash( hash, key_map )
+          hash.each_with_object( {} ) do |(key, value), json_hash|
+            converted_key = convert_key_from_json( key, key_map )
+            json_hash[converted_key] =
+              if value.respond_to?(:each)
+                convert_collection( key, value )
+              else
+                value
+              end
+          end
+        end
+
+        def convert_collection( key, collection )
+          mapper_name = key.downcase
+          if Registry.key?(mapper_name)
+            convert_nested_data( mapper_name, key, collection )
+          else
+            # NOTE: This probably means this is a nested model that we have
+            # not implemented yet, or that is missing a mapper.
+            # Raise exception during test run if this happens so that we can
+            # add it before a new release.
+
+            raise MissingModelOrMapperException, "for #{ key } (#{ mapper_name }, #{ Fortnox::API::Mapper::DefaultTemplates.canonical_name_sym }) with #{ collection }" if ENV['RUBY_ENV']
+            Fortnox::API.logger.warn( "Missing Model or Mapper implementation for #{ key } with attributes: #{ collection }" )
+            return convert_hash_keys_from_json_format( collection, {} )
+          end
+        end
+
+        def convert_nested_data( _mapper_name, key, nested_data )
+          nested_mapper = Registry[ key.downcase ]
+          if nested_data.is_a?(::Array) # Array of nested models
+            return nested_data.each_with_object( [] ) do |value, nested_models|
+              nested_models << json_hash_to_entity_hash( value, nested_mapper::KEY_MAP )
+            end
+          else # Assume Hash of nested model
+            return json_hash_to_entity_hash( nested_data, nested_mapper::KEY_MAP )
+          end
+        end
+
+        def convert_key_from_json( key, key_map )
+          key_map.key( key ) || default_key_from_json_transform( key )
+        end
+
+        def default_key_from_json_transform( key )
+          key = key.to_s
+          unless key =~ /\A[A-Z]+\z/
+            key = key.gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').gsub(/([a-z])([A-Z])/, '\1_\2')
+          end
+          key.downcase.to_sym
+        end
+      end
+    end
+  end
+end

data/lib/fortnox/api/mappers/base/to_json.rb

@@ -0,0 +1,65 @@
+module Fortnox
+  module API
+    module Mapper
+      module ToJSON
+        def self.included(base)
+          base.instance_eval do
+
+            # PUBLIC
+
+            def call( entity, keys_to_filter = {} )
+              entity_hash = entity.to_hash
+              clean_entity_hash = sanitise( entity_hash, keys_to_filter )
+              clean_entity_hash = convert_hash_keys_to_json_format( clean_entity_hash )
+              Registry[:hash].call( clean_entity_hash )
+            end
+
+            # PRIVATE
+
+            def convert_hash_keys_to_json_format( hash )
+              hash.each_with_object( {} ) do |(key, value), json_hash|
+                json_hash[ convert_key_to_json( key ) ] = value
+              end
+            end
+
+            def convert_key_to_json( key )
+              self::KEY_MAP.fetch( key ){ default_key_to_json_transform( key ) }
+            end
+
+            def default_key_to_json_transform( key )
+              key.to_s.split('_').map(&:capitalize).join('')
+            end
+
+            def sanitise( hash, keys_to_filter )
+              hash.select do |key, value|
+                next false if keys_to_filter.include?( key )
+                value != nil
+              end
+            end
+
+            private_class_method :convert_hash_keys_to_json_format,
+                                 :convert_key_to_json,
+                                 :default_key_to_json_transform,
+                                 :sanitise
+          end
+        end
+
+        def entity_to_hash( entity, keys_to_filter )
+          entity_json_hash = Registry[ mapper_name_for( entity ) ]
+                             .call( entity, keys_to_filter )
+          wrapp_entity_json_hash( entity_json_hash )
+        end
+
+        def wrapp_entity_json_hash( entity_json_hash )
+          { self.class::JSON_ENTITY_WRAPPER => entity_json_hash }
+        end
+
+        private
+
+          def mapper_name_for( value )
+            value.class.name.split('::').last.downcase.to_sym
+          end
+      end
+    end
+  end
+end

data/lib/fortnox/api/mappers/customer.rb

@@ -0,0 +1,27 @@
+require "fortnox/api/mappers/base"
+
+module Fortnox
+  module API
+    module Mapper
+      class Customer < Fortnox::API::Mapper::Base
+
+        KEY_MAP = {
+          vat_type: 'VATType',
+          vat_number: 'VATNumber',
+          email_invoice_bcc: 'EmailInvoiceBCC',
+          email_invoice_cc: 'EmailInvoiceCC',
+          email_offer_bcc: 'EmailOfferBCC',
+          email_offer_cc: 'EmailOfferCC',
+          email_order_bcc: 'EmailOrderBCC',
+          email_order_cc: 'EmailOrderCC',
+          show_price_vat_included: 'ShowPriceVATIncluded',
+        }.freeze
+        JSON_ENTITY_WRAPPER = 'Customer'.freeze
+        JSON_COLLECTION_WRAPPER = 'Customers'.freeze
+
+      end
+
+      Registry.register( Customer.canonical_name_sym, Customer )
+    end
+  end
+end