kounta_rest 0.1.7 → 0.2.4

data/lib/kounta/price_list.rb

@@ -1,10 +1,8 @@
 module Kounta
-
-	class PriceList < Kounta::Resource
-		property :parent_id
-		property :name
-		property :products
-		coerce_key :products, Product
-	end
-
-end
+  class PriceList < Kounta::Resource
+    property :parent_id
+    property :name
+    property :products
+    coerce_key :products, Product
+  end
+end

data/lib/kounta/product.rb

@@ -1,31 +1,29 @@
 module Kounta
+  class Product < Kounta::Resource
+    property :company_id
+    property :code
+    property :barcode
+    property :stock
+    property :name
+    property :description
+    property :tags
+    property :image
+    property :unit_price
+    property :cost_price
+    property :taxes
+    property :sites
+    property :number
 
-	class Product < Kounta::Resource
-		property :company_id
-		property :code
-		property :barcode
-		property :stock
-		property :name
-		property :description
-		property :tags
-		property :image
-		property :unit_price
-		property :cost_price
-		property :taxes
-		property :sites
-		property :number
+    has_many(:categories, Kounta::Category, { company_id: :company_id },
+             proc { |klass| { companies: klass.company_id, products: klass.id, categories: nil } })
+    coerce_key :taxes, Kounta::Tax
 
-		has_many :categories, Kounta::Category, {:company_id => :company_id}, lambda { |klass| {companies: klass.company_id, products: klass.id, categories: nil} }
-		coerce_key :taxes, Kounta::Tax
+    def tags_include?(name)
+      tags.any? { |s| s.casecmp(name).zero? }
+    end
 
-		def tags_include?(name)
-			tags.any?{ |s| s.casecmp(name) == 0 }
-		end
-
-		def resource_path
-			{companies: company_id, products: id}
-		end
-
-	end
-
-end
+    def resource_path
+      { companies: company_id, products: id }
+    end
+  end
+end

data/lib/kounta/register.rb

@@ -1,15 +1,12 @@
 module Kounta
-
-	class Register < Kounta::Resource
-		property :company_id
-		property :code
-		property :name
-		property :site_id
-
-		def resource_path
-			{companies: company_id, registers: id}
-		end
-
-	end
-
-end
+  class Register < Kounta::Resource
+    property :company_id
+    property :code
+    property :name
+    property :site_id
+
+    def resource_path
+      { companies: company_id, registers: id }
+    end
+  end
+end

data/lib/kounta/resource.rb

@@ -1,96 +1,108 @@
 require 'hashie'
-require_relative "rest/client"
+require_relative 'rest/client'
 
 module Kounta
-
-	class Resource < Hashie::Dash
-		include Hashie::Extensions::Coercion
-
-		property :id
-		property :created_at
-		property :updated_at
-
-		def self.coerce(data)
-			if data.kind_of? Array
-				data.map { |item| self.new(item) }
-			else
-				self.new(data)
-			end
-		end
-
-		def self.has_one(sym, klass, assignments, route)
-			define_method(sym) do |item_id=nil, *args|
-				if item_id
-					assign_into(client.object_from_response(klass, :get, route.call(self, item_id), {:params => args[0]}), self, assignments)
-				else
-					assign_into(klass.new, self, assignments)
-				end
-			end
-		end
-
-		def self.has_many(sym, klass, assignments, route)
-			define_method(sym) do |*args|
-				client.objects_from_response(klass, :get, route.call(self), {:params => args[0]}).map {|returned_klass| assign_into(returned_klass, self, assignments) }
-			end
-		end
-
-		def initialize(hash={})
-			if hash
-				hash.each_pair do |k,v|
-					begin
-						self[k] = v if self.respond_to? k.to_sym
-					rescue NoMethodError => e
-						raise Kounta::Errors::UnknownResourceAttribute.new("Unknown attribute: #{k} on resource #{self.class}")
-					end
-				end
-			end
-		end
-
-		def client
-			@@client ||= Kounta::REST::Client.new
-		end
-
-		def to_hash(hash={})
-			{}.tap do |returning|
-				self.class.properties.each do |property|
-					next if ignored_properties.include?(property)
-					returning[property] = self[property] if self[property]
-				end
-			end.merge(hash)
-		end
-
-		def save!
-			response = new? ? client.perform(resource_path, :post, {:body => to_hash}) : client.perform(resource_path, :put, {:body => to_hash})
-
-			# automatically follow redirects to resources
-			if response.status == 201
-				response = client.perform(response.headers["location"], :get)
-			end
-
-			response.parsed.each_pair do |k,v|
-				self[k] = v if self.respond_to? k.to_sym
-			end
-
-			self
-		end
-
-		def new?
-			!id
-		end
-
-		def ignored_properties(array=[])
-			array + [:created_at, :updated_at, :id, :company_id]
-		end
-
-		private
-
-			def assign_into(klass, assigner, assignments)
-				assignments.each_pair do |k,v|
-					klass[k] = assigner[v]
-				end
-				klass
-			end
-
-	end
-
-end
+  class Resource < Hashie::Dash
+    include Hashie::Extensions::Dash::IndifferentAccess if defined?(Hashie::Extensions::Dash::IndifferentAccess)
+    include Hashie::Extensions::Coercion
+
+    attr_accessor :client
+
+    property :id
+    property :created_at
+    property :updated_at
+
+    def self.coerce(data)
+      if data.is_a? Array
+        data.map { |item| new(item) }
+      else
+        new(data)
+      end
+    end
+
+    def self.has_one(sym, klass, assignments, route) # rubocop:disable Naming/PredicateName
+      define_method(sym) do |item_id = nil, *args|
+        if item_id
+          assign_into(client.object_from_response(klass, :get, route.call(self, item_id), params: args[0]), self, assignments)
+        else
+          assign_into(klass.new, self, assignments)
+        end
+      end
+    end
+
+    def self.has_many(sym, klass, assignments, route) # rubocop:disable Naming/PredicateName
+      define_method(sym) do |has_many_params = nil, *args|
+        client.objects_from_response(klass, :get, route.call(self, has_many_params), params: args[0])
+              .map { |returned_klass| assign_into(returned_klass, self, assignments) }
+      end
+    end
+
+    def self.has_many_in_time_range(sym, klass, assignments, route) # rubocop:disable Naming/PredicateName
+      define_method(sym) do |has_many_params = nil, *args|
+        client.objects_from_response_in_time_range(klass, :get, route.call(self, has_many_params), params: args[0])
+              .map { |returned_klass| assign_into(returned_klass, self, assignments) }
+      end
+    end
+
+    def initialize(hash = {})
+      return unless hash
+
+      hash.each_pair do |k, v|
+        begin
+          self[k] = v if respond_to? k.to_sym
+        rescue NoMethodError
+          raise Kounta::Errors::UnknownResourceAttribute, "Unknown attribute: #{k} on resource #{self.class}"
+        end
+      end
+    end
+
+    def to_hash(hash = {})
+      {}.tap do |returning|
+        self.class.properties.each do |property|
+          next if ignored_properties.include?(property)
+          returning[property] = self[property] if self[property]
+        end
+      end.merge(hash)
+    end
+
+    def save!
+      response = new? ? client.perform(resource_path, :post, body: to_hash) : client.perform(resource_path, :put, body: to_hash)
+
+      # automatically follow redirects to resources
+      response = client.perform(response.headers['location'], :get) if response.status == 201
+
+      response.parsed.each_pair do |k, v|
+        self[k] = v if respond_to? k.to_sym
+      end
+
+      self
+    end
+
+    def delete!
+      return self if new?
+      response = client.perform(resource_path, :delete)
+
+      except!('id', 'created_at', 'updated_at') if response.status == 204
+
+      self
+    end
+
+    def new?
+      !id
+    end
+
+    def ignored_properties(array = [])
+      array + %i[created_at updated_at id company_id]
+    end
+
+    private
+
+    def assign_into(klass, assigner, assignments)
+      klass.client = assigner.client
+      assignments.each_pair do |k, v|
+        klass[k] = assigner[v]
+      end
+      klass
+    end
+  end
+end

data/lib/kounta/rest/client.rb

@@ -3,82 +3,180 @@ require 'oj'
 require 'faraday_middleware'
 
 module Kounta
-	module REST
-		class Client
-
-			def initialize
-				raise Kounta::Errors::MissingOauthDetails unless has_required_oauth_details?
-				@conn = OAuth2::AccessToken.new(client, Kounta.client_token, {:refresh_token => Kounta.client_refresh_token})
-			end
-
-			def client
-				@oauth_client ||= OAuth2::Client.new(Kounta.client_id, Kounta.client_secret, {
-					:site => Kounta::SITE_URI,
-					:authorize_url => Kounta::AUTHORIZATION_URI,
-					:token_url => Kounta::TOKEN_URI
-				}) do |faraday|
-					faraday.request :json
-					faraday.use Faraday::Request::UrlEncoded
-					faraday.use Faraday::Response::Logger if Kounta.enable_logging
-					faraday.adapter Faraday.default_adapter
-				end
-			end
-
-			def path_from_hash(url_hash)
-				url_hash.map{ |key, value| value ? "#{key}/#{value}" : "#{key}" }.join('/')
-			end
-
-			def perform(url_hash, request_method, options={})
-				begin
-					if url_hash.kind_of? Hash
-						response = @conn.request(request_method, "#{path_from_hash(url_hash)}.#{FORMAT.to_s}", options)
-					else
-						response = @conn.request(request_method, url_hash, options)
-					end
-				rescue OAuth2::Error => ex
-					puts "-- in error"
-					puts response.inspect
-					if ex.message.include?('expired') || ex.message.include?('invalid')
-						@conn = refreshed_token
-						retry
-					end
-					
-					#raise Kounta::Errors::APIError.new(ex.message)
-				end
-				response
-			end
-
-			def objects_from_response(klass, request_method, url_hash, options={})
-				response = perform(url_hash, request_method, options)
-				page_count = response.headers["x-pages"].to_i
-
-				if page_count > 1
-					results = []
-					page_count.times { |page_number|
-						response = perform(url_hash, request_method, options.merge!(:headers => {'X-Page' => (page_number).to_s}))
-						results = results + response.parsed
-					}
-					results.map { |item| klass.new(item) }
-				else
-					response.parsed.map { |item| klass.new(item) }
-				end
-			end
-
-			def object_from_response(klass, request_method, url_hash, options={})
-				response = perform(url_hash, request_method, options)
-				klass.new(response.parsed)
-			end
-
-			private
-
-				def has_required_oauth_details?
-					Kounta.client_id && Kounta.client_secret && Kounta.client_token && Kounta.client_refresh_token
-				end
-
-				def refreshed_token
-					OAuth2::AccessToken.from_hash(client, :refresh_token => Kounta.client_refresh_token).refresh!
-				end
-
-		end
-	end
-end
+  module REST
+    class Client
+      def initialize(**options)
+        @redirect_uri         = options[:redirect_uri]
+        @consumer             = options[:consumer]
+        @access_token         = options[:access_token]
+        @refresh_token        = options[:refresh_token]
+        @client               = OAuth2::Client.new(
+          @consumer[:key], @consumer[:secret],
+          site: Kounta::SITE_URI,
+          authorize_url: Kounta::AUTHORIZATION_URI,
+          token_url: Kounta::TOKEN_URI
+        ) do |faraday|
+          faraday.request :json
+          faraday.use Faraday::Request::UrlEncoded
+          faraday.use Faraday::Response::Logger if Kounta.enable_logging
+          faraday.adapter Faraday.default_adapter
+        end
+      end
+
+      def authenticated?
+        @access_token.present?
+      end
+
+      def get_access_code_url(params = {})
+        # Kounta's API seems to require the `state` param (can't find documentation on it anywhere)
+        # learn more about it: http://homakov.blogspot.com.au/2012/07/saferweb-most-common-oauth2.html
+        @client.auth_code.authorize_url(params.merge(redirect_uri: @redirect_uri, state: SecureRandom.hex(24)))
+      end
+
+      def get_access_token(access_code)
+        @token = @client.auth_code.get_token(access_code, redirect_uri: @redirect_uri)
+        @access_token = @token.token
+        @expires_at = @token.expires_at
+        @refresh_token = @token.refresh_token
+        @token
+      end
+
+      def company(hash = {})
+        @company ||= Kounta::Company.new(self, hash)
+      end
+
+      def path_from_hash(url_hash)
+        # TODO: there's probably a more correct way of doing this encoding
+        url_hash.map { |key, value| value ? "#{key}/#{value.to_s.gsub('-', '%2D')}" : key.to_s }.join('/')
+      end
+
+      def perform(url_hash, request_method, options = {})
+        begin
+          response = if url_hash.is_a? Hash
+                       oauth_connection.request(request_method, "#{path_from_hash(url_hash)}.#{FORMAT}", options)
+                     else
+                       oauth_connection.request(request_method, url_hash, options)
+                     end
+        rescue Exception => ex # rubocop:disable Lint/RescueException
+          msg = ex.message
+          if !msg.nil? && (msg.include?('The access token provided has expired') || msg.include?('expired') || msg.include?('invalid'))
+            @oauth_connection = refreshed_token
+            retry
+          end
+
+          raise Kounta::Errors::RequestError, response.nil? ? 'Unknown Status' : response.status
+        end
+
+        raise Kounta::Errors::RequestError, 'Unknown Status' unless response
+
+        response
+      end
+
+      def objects_from_response(klass, request_method, url_hash, options = {})
+        response = perform(url_hash, request_method, options)
+        last_page = response.headers['x-pages'].to_i - 1
+        results = response.parsed
+
+        # Already got page 0, start at page 1
+        (1..last_page).each do |page_number|
+          response = perform(url_hash, request_method, options.merge!(headers: { 'X-Page' => page_number.to_s }))
+          results += response.parsed
+        end
+
+        results.map { |item| klass.new(item) }
+      end
+
+      def object_from_response(klass, request_method, url_hash, options = {})
+        response = perform(url_hash, request_method, options)
+        klass.new(response.parsed)
+      end
+
+      def objects_from_response_in_time_range(klass, request_method, url_hash, options = {})
+        if options.key?(:params) && (options[:params].key?(:created_gte) ^ options[:params].key?(:created_gt)) &&
+           (options[:params].key?(:created_lte) ^ options[:params].key?(:created_lt))
+          params = options[:params]
+          start_equal = params.key?(:created_gte)
+          finish_equal = params.key?(:created_lte)
+          start = (start_equal ? params[:created_gte] : params[:created_gt]).to_time
+          finish = (finish_equal ? params[:created_lte] : params[:created_lt]).to_time
+
+          params.except!(:created_gte, :created_gt, :created_lte, :created_lt)
+
+          start_date = start.to_date
+          finish_date = finish.to_date
+
+          start = start.to_i
+          finish = finish.to_i
+
+          results = []
+
+          options[:params] = params.merge(created_gte: start_date, created_lte: finish_date)
+          response = perform(url_hash, request_method, options)
+          last_page = response.headers['x-pages'].to_i - 1
+          parsed = response.parsed.map do |o|
+            o['created_at_epoch'] = Time.parse(o['created_at']).to_i
+            o
+          end
+
+          response_start = parsed.last['created_at_epoch']
+          response_finish = parsed.first['created_at_epoch']
+
+          # all current and future responses will be before the required start
+          return results if response_finish < start
+
+          # reverse to order them in ascending order
+          results += filter_responses_in_date_range(parsed.reverse, start, finish)
+
+          # all future responses will be before the required start
+          return results if response_start < start
+
+          (1..last_page).each do |page_number|
+            response = perform(url_hash, request_method, options.merge!(headers: { 'X-Page' => page_number.to_s }))
+            parsed = response.parsed.map do |o|
+              o['created_at_epoch'] = Time.parse(o['created_at']).to_i
+              o
+            end
+
+            response_start = parsed.last['created_at_epoch']
+            response_finish = parsed.first['created_at_epoch']
+
+            # all current and future responses will be before the required start
+            break if response_finish < start
+
+            # reverse to order them in ascending order
+            results += filter_responses_in_date_range(parsed.reverse, start, finish)
+
+            # all future responses will be before the required start
+            break if response_start < start
+          end
+
+          # reverse to under reverses used to order them in ascending order
+          results.reverse.map { |item| klass.new(item) }
+        else
+          raise ArgumentError, 'url_has must contain exactly one of [:created_gte, :created_gt] ' \
+                               'and exactly one of [:created_lte, :created_lt]'
+        end
+      end
+
+      def filter_responses_in_date_range(parsed_responses, start, finish)
+        start_index = parsed_responses.index { |response| response['created_at_epoch'] >= start } || parsed_responses.length - 1
+        finish_index = parsed_responses.rindex { |response| response['created_at_epoch'] <= finish } || 0
+        parsed_responses[start_index..finish_index]
+      end
+
+      private
+
+      def oauth_connection
+        @oauth_connection ||= if @refresh_token
+                                OAuth2::AccessToken.new(@client, @access_token, refresh_token: @refresh_token).refresh!
+                              else
+                                OAuth2::AccessToken.new(@client, @access_token)
+                              end
+      end
+
+      def refreshed_token
+        OAuth2::AccessToken.from_hash(@client, refresh_token: @refresh_token).refresh!
+      end
+    end
+  end
+end

data/lib/kounta/shift.rb

@@ -0,0 +1,25 @@
+module Kounta
+  class Shift < Kounta::Resource
+    property :company_id
+    property :staff_member
+    property :site
+    property :started_at
+    property :finished_at
+    property :breaks
+
+    # coerce_key :staff_member, Kounta::Staff
+    # coerce_key :site, Kounta::Site
+    coerce_key :breaks, Kounta::Break
+
+    def initialize(hash = {})
+      super(hash)
+      self.breaks ||= []
+    end
+
+    def to_hash
+      returning = {}
+      returning[:breaks] = breaks.map(&:to_hash) if breaks && !breaks.empty?
+      super(returning)
+    end
+  end
+end