turba_kit 0.0.8 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 032cbfe91ba7465a1f61586f8147bf6745c64bdc
-  data.tar.gz: ff76c291e3c7ef08df77e3dd9c0a3b700d2f7001
+  metadata.gz: e5209bf98ef2ab1dd6e3f084de4d71f26ef9d12d
+  data.tar.gz: f598ddb1f93ed74eb97ac1c0fb162c2a77d3abc9
 SHA512:
-  metadata.gz: a713192585164fe8fba1633340d652235e409e23956ab031ef0f0498893487d56ad2b80b00035efd6c3f5fb1da45c7dc5458537f43cea89f6f738cec28969a3c
-  data.tar.gz: 9f2369295552e66e3cd1ee5be8538f38d9469382dc884eea2a2fe84ac464cea72ac755e0e7f12d8ee001dee61b1ef73b8b94c451a7d0ce8d7fb2d98ab9182883
+  metadata.gz: 9781057e03f8b80e756188bdcc132384bd73a0ce20f940018c9e1dc017ef46008122d38623bf427895dc9ee0e48f30b3f1078f689e391af954a5246ec373dab5
+  data.tar.gz: 4cfc61901cd6dff83d5e890e1338479c3cbdf4c8179fd3db16d429998880f2f1945fb6692379eaad1eada6e4bcc8cb3096d795a79fbd257c666c76e010264fc8

data/.ruby-version

@@ -0,0 +1 @@
+2.2.2

data/Gemfile

@@ -1,15 +1,8 @@
 source 'https://rubygems.org'
 
 gem 'rake'
-gem 'faraday'
-gem 'sawyer'
 
 group :test do
-  gem 'webmock'
-  gem 'vcr'
-  gem 'turn'
-  gem 'rake'
-  gem 'rspec', '~> 3.0.0.beta2'
 end
 
 gemspec

data/lib/turba_kit.rb

@@ -1,27 +1,126 @@
-require 'turba_kit/client'
-require 'turba_kit/default'
+require 'oj'
+require 'typhoeus'
+require 'recursive-open-struct'
+require 'turba_kit/error'
+require 'turba_kit/countries'
+require 'turba_kit/checkins'
+require 'turba_kit/availability'
+require 'turba_kit/units'
+require 'turba_kit/services'
+require 'turba_kit/crowd_table'
+require 'turba_kit/link'
+require 'turba_kit/misc'
+require 'turba_kit/call_to_action'
+require 'turba_kit/phonenumber'
+require 'turba_kit/tip'
+require 'turba_kit/content'
+require 'turba_kit/place'
+require 'turba_kit/notification'
+require 'active_support/core_ext/hash'
 
-# Ruby toolkit for the Turba API
 module TurbaKit
-  class << self
-    include TurbaKit::Configurable
-    def client
-      @client = TurbaKit::Client.new(options) unless defined?(@client) && @client.same_options?(options)
-      @client
+  class Client
+    include TurbaKit::Countries
+    include TurbaKit::Checkins
+    include TurbaKit::Availability
+    include TurbaKit::Units
+    include TurbaKit::Services
+    include TurbaKit::CrowdTable
+    include TurbaKit::Link
+    include TurbaKit::Misc
+    include TurbaKit::CallToAction
+    include TurbaKit::Phonenumber
+    include TurbaKit::Tip
+    include TurbaKit::Content
+    include TurbaKit::Place
+    include TurbaKit::Notification
+
+    def initialize(api_key, options = {})
+      @api_key = api_key
+      default_options = {
+        version: '/v2',
+        domain: 'api.turba-webservices.com',
+        scheme: 'https'
+      }
+      @options = default_options.merge(options)
+    end
+
+    def api_url
+      @api_url ||= "#{@options[:scheme]}://#{@options[:domain]}#{@options[:version]}"
+    end
+
+    def default_params
+      @default_params ||= { api_key: @api_key }
+    end
+
+    def put_request(endpoint, options = {})
+      options[:namespace] ||= nil
+      options[:accept] ||= "application/json"
+      options[:params] ||= {}
+
+      request = Typhoeus::Request.new(
+        "#{api_url}#{endpoint}",
+        method: :put,
+        params: default_params,
+        body: Oj.dump(options[:params], mode: :compat),
+        headers: { "Content-Type" => options[:accept] }
+      ).run
+      response(request, options[:namespace])
+    end
+
+    def post_request(endpoint, options = {})
+      options[:namespace] ||= nil
+      options[:accept] ||= "application/json"
+      options[:params] ||= {}
+
+      request = Typhoeus::Request.new(
+        "#{api_url}#{endpoint}",
+        method: :post,
+        params: default_params,
+        body: Oj.dump(options[:params], mode: :compat),
+        headers: { "Content-Type" => options[:accept] }
+      ).run
+      response(request, options[:namespace])
+    end
+
+    def delete_request(endpoint)
+      request = Typhoeus::Request.new(
+        "#{api_url}#{endpoint}",
+        method: :delete,
+        params: default_params,
+      ).run
+
+      response(request, nil)
+    end
+
+    def get_request(endpoint, options = {})
+      options[:namespace] ||= nil
+      options[:accept] ||= "application/json"
+      options[:params] ||= {}
+
+      request = Typhoeus::Request.new(
+        "#{api_url}#{endpoint}",
+        method: :get,
+        params: default_params.merge(options[:params]),
+        headers: { Accept: options[:accept] }
+      ).run
+
+      response(request, options[:namespace])
     end
 
-    # @private
-    def respond_to_missing?(method_name, include_private=false); client.respond_to?(method_name, include_private); end if RUBY_VERSION >= "1.9"
-    # @private
-    def respond_to?(method_name, include_private=false); client.respond_to?(method_name, include_private) || super; end if RUBY_VERSION < "1.9"
+    def response(request, namespace)
+      body = Oj.load(request.body)
+      body = body.with_indifferent_access unless body.nil?
+      status = request.options[:response_code]
+      body ||= request.body
 
-  private
+      if (400..599).include?(status)
+        return Error.from_response(body, status)
+      end
 
-    def method_missing(method_name, *args, &block)
-      return super unless client.respond_to?(method_name)
-      client.send(method_name, *args, &block)
+      return "" if body.empty?
+
+      namespace ? RecursiveOpenStruct.new(body[namespace], recurse_over_arrays: true) : RecursiveOpenStruct.new(body, recurse_over_arrays: true)
     end
   end
 end
-
-TurbaKit.setup

data/lib/turba_kit/availability.rb

@@ -0,0 +1,7 @@
+module TurbaKit
+  module Availability
+    def availability
+      get_request('/status')
+    end
+  end
+end

data/lib/turba_kit/call_to_action.rb

@@ -0,0 +1,25 @@
+module TurbaKit
+  module CallToAction
+    def update_service_call_to_action(service_id, call_to_action_id, options = {})
+      put_request("/services/#{service_id}/call_to_actions/#{call_to_action_id}", {
+        namespace: :call_to_action,
+        params: {
+          call_to_action: options
+        }
+      })
+    end
+
+    def create_service_call_to_action(service_id, options = {})
+      post_request("/services/#{service_id}/call_to_actions", {
+        namespace: :call_to_action,
+        params: {
+          call_to_action: options
+        }
+      })
+    end
+
+    def delete_service_call_to_action(service_id, call_to_action_id, options = {})
+      delete_request("/services/#{service_id}/call_to_actions/#{call_to_action_id}")
+    end
+  end
+end

data/lib/turba_kit/checkins.rb

@@ -0,0 +1,30 @@
+module TurbaKit
+  module Checkins
+    def checkins(options = {})
+      default = {
+        page: 0,
+        per_page: 10,
+        published: true,
+        country_code: 'FR',
+        type: 'parent'
+      }
+
+      get_request("/checkins", {params: default.merge(options)})
+    end
+
+    def create_checkin(service_id, wait, options = {})
+      default = {
+        user: :guest,
+        location: 'N/A',
+        platform: :web,
+        service_id: service_id,
+        wait: wait
+      }
+      post_request("/checkins", {
+        params: {
+          checkin: default.merge(options)
+        }
+      })
+    end
+  end
+end

data/lib/turba_kit/content.rb

@@ -0,0 +1,25 @@
+module TurbaKit
+  module Content
+    def update_service_content(service_id, content_id, options = {})
+      put_request("/services/#{service_id}/contents/#{content_id}", {
+        namespace: :content,
+        params: {
+          content: options
+        }
+      })
+    end
+
+    def create_service_content(service_id, options = {})
+      post_request("/services/#{service_id}/contents", {
+        namespace: :content,
+        params: {
+          content: options
+        }
+      })
+    end
+
+    def delete_service_content(service_id, content_id, options = {})
+      delete_request("/services/#{service_id}/contents/#{content_id}")
+    end
+  end
+end

data/lib/turba_kit/countries.rb

@@ -0,0 +1,11 @@
+module TurbaKit
+  module Countries
+    def countries
+      get_request('/countries', {namespace: :countries})
+    end
+
+    def country(country_code)
+      get_request("/countries/#{country_code}", {namespace: :country})
+    end
+  end
+end

data/lib/turba_kit/crowd_table.rb

@@ -0,0 +1,37 @@
+module TurbaKit
+  module CrowdTable
+    def service_crowd_table(service_id, options = {})
+      default = {
+        from: Time.now.beginning_of_day.to_datetime.new_offset(0).to_i,
+        to: (Time.now + 6.days).beginning_of_day.to_datetime.new_offset(0).to_i
+      }
+
+      get_request("/services/#{service_id}/crowd_table", {
+        namespace: :crowd_table,
+        params: default.merge(options)
+      })
+    end
+
+    def update_service_crowd_table(service_id, crowd_table_id, options = {})
+      put_request("/services/#{service_id}/crowd_tables/#{crowd_table_id}", {
+        namespace: :crowd_table,
+        params: {
+          crowd_table: options
+        }
+      })
+    end
+
+    def create_service_crowd_table(service_id, options = {})
+      post_request("/services/#{service_id}/crowd_table", {
+        namespace: :crowd_table,
+        params: {
+          crowd_table: options
+        }
+      })
+    end
+
+    def delete_service_crowd_table(service_id, options = {})
+      delete_request("/services/#{service_id}/crowd_table")
+    end
+  end
+end

data/lib/turba_kit/error.rb

@@ -1,23 +1,12 @@
 module TurbaKit
-  # Custom error class for rescuing from all Turba errors
   class Error < StandardError
-    attr_accessor :hash_message
-
-    # Returns the appropriate TurbaKit::Error subclass based
-    # on status and response message
-    #
-    # @param [Hash] response HTTP response
-    # @return [TurbaKit::Error]
-    def self.from_response(response)
-      status  = response[:status].to_i
-      body    = response[:body].to_s
-      headers = response[:response_headers]
-
-      if klass =  case status
+    def self.from_response(body, status)
+      if klass =  case status.to_i
                   when 400      then TurbaKit::BadRequest
-                  when 401      then error_for_401(headers)
-                  when 403      then error_for_403(body)
+                  when 401      then TurbaKit::Unauthorized
+                  when 403      then TurbaKit::Forbidden
                   when 404      then TurbaKit::NotFound
+                  when 405      then TurbaKit::MethodNotAllowed
                   when 406      then TurbaKit::NotAcceptable
                   when 409      then TurbaKit::Conflict
                   when 415      then TurbaKit::UnsupportedMediaType
@@ -29,181 +18,38 @@ module TurbaKit
                   when 503      then TurbaKit::ServiceUnavailable
                   when 500..599 then TurbaKit::ServerError
                   end
-        klass.new(response)
-      end
-    end
-
-    def initialize(response=nil)
-      @response = response
-      super(build_error_message)
-      @status = @response[:status]
-      @hash_message = build_hash_message
-    end
-
-    # Documentation URL returned by the API for some errors
-    #
-    # @return [String]
-    def documentation_url
-      data[:documentation_url] if data.is_a? Hash
-    end
-
-    # Returns most appropriate error for 401 HTTP status code
-    # @private
-    def self.error_for_401(headers)
-      if TurbaKit::OneTimePasswordRequired.required_header(headers)
-        TurbaKit::OneTimePasswordRequired
-      else
-        TurbaKit::Unauthorized
-      end
-    end
-
-    # Returns most appropriate error for 403 HTTP status code
-    # @private
-    def self.error_for_403(body)
-      if body =~ /rate limit exceeded/i
-        TurbaKit::TooManyRequests
-      elsif body =~ /login attempts exceeded/i
-        TurbaKit::TooManyLoginAttempts
-      else
-        TurbaKit::Forbidden
+        klass.new(body, status)
       end
     end
 
-    # Array of validation errors
-    # @return [Array<Hash>] Error info
-    def errors
-      if data && data.is_a?(Hash)
-        data[:errors] || []
-      else
-        []
-      end
-    end
-
-    private
-
-    def data
-      @data ||=
-        if (body = @response[:body]) && !body.empty?
-          if body.is_a?(String) &&
-            @response[:response_headers] &&
-            @response[:response_headers][:content_type] =~ /json/
-
-            Sawyer::Agent.serializer.decode(body)
-          else
-            body
-          end
-        else
-          nil
-        end
-    end
-
-    def response_message
-      case data
-      when Hash
-        data[:message]
-      when String
-        data
-      end
-    end
-
-    def response_error
-      "Error: #{data[:error]}" if data.is_a?(Hash) && data[:error]
-    end
-
-    def response_error_summary
-      return nil unless data.is_a?(Hash) && !Array(data[:errors]).empty?
-      summary = "\nError summary:\n"
-      summary << data[:errors].map{|x| x}.join("\n")
-      summary
-    end
-
-    def build_hash_message
-      response = {}
-      return response if @response.nil?
-      response[:method] = @response[:method].to_s.upcase
-      response[:status] = @response[:status]
-      response[:message] = response_message unless response_message.nil?
-
-      data_array = data[:errors].map do |x|
-        x.is_a?(Hash) ? x[:message] : x
-      end unless data[:errors].blank?
-
-      response[:errors] = data_array
-      response[:documentation_url] = documentation_url unless documentation_url.nil?
-      response
-    end
-
-    def build_error_message
-      return nil if @response.nil?
+    def initialize(body, status)
+      message = {
+        status: status,
+        error: body['error']
+      }
 
-      message =  "#{@response[:method].to_s.upcase} "
-      message << redact_url(@response[:url].to_s) + ": "
-      message << "#{@response[:status]} - "
-      message << "#{response_message}" unless response_message.nil?
-      message << "#{response_error}" unless response_error.nil?
-      message << "#{response_error_summary}" unless response_error_summary.nil?
-      message << " // See: #{documentation_url}" unless documentation_url.nil?
-      message
+      super(Oj.dump(message, mode: :compat)) 
+      raise self
     end
 
-    def redact_url(url_string)
-      %w[api_key].each do |token|
-        url_string.gsub!(/#{token}=\S+/, "#{token}=(redacted)") if url_string.include? token
-      end
-      url_string
-    end
   end
 
   # Raised on errors in the 400-499 range
   class ClientError < Error; end
-
-  # Raised when Turba returns a 400 HTTP status code
   class BadRequest < ClientError; end
-
-  # Raised when Turba returns a 401 HTTP status code
   class Unauthorized < ClientError; end
-
-  # Raised when Turba returns a 403 HTTP status code
   class Forbidden < ClientError; end
-
-  # Raised when Turba returns a 403 HTTP status code
-  # and body matches 'rate limit exceeded'
-  class TooManyRequests < Forbidden; end
-
-  # Raised when Turba returns a 403 HTTP status code
-  # and body matches 'login attempts exceeded'
-  class TooManyLoginAttempts < Forbidden; end
-
-  # Raised when Turba returns a 404 HTTP status code
   class NotFound < ClientError; end
-
-  # Raised when Turba returns a 406 HTTP status code
+  class MethodNotAllowed < ClientError; end
   class NotAcceptable < ClientError; end
-
-  # Raised when Turba returns a 409 HTTP status code
   class Conflict < ClientError; end
-
-  # Raised when Turba returns a 414 HTTP status code
   class UnsupportedMediaType < ClientError; end
-
-  # Raised when Turba returns a 422 HTTP status code
   class UnprocessableEntity < ClientError; end
-
-  # Raised on errors in the 500-599 range
   class ServerError < Error; end
-
-  # Raised when Turba returns a 500 HTTP status code
   class InternalServerError < ServerError; end
-
-  # Raised when Turba returns a 501 HTTP status code
   class NotImplemented < ServerError; end
-
-  # Raised when Turba returns a 502 HTTP status code
   class BadGateway < ServerError; end
-
-  # Raised when Turba returns a 503 HTTP status code
   class ServiceUnavailable < ServerError; end
-
-  # Raised when client fails to provide valid Content-Type
   class MissingContentType < ArgumentError; end
+  class ApplicationCredentialsRequired < StandardError; end
 end