pactas_itero 0.2.0

data/lib/pactas_itero/client.rb

@@ -0,0 +1,108 @@
+require 'base64'
+require 'rash'
+require 'pactas_itero/configurable'
+require 'pactas_itero/api'
+
+module PactasItero
+  class Client
+    include PactasItero::Configurable
+    include PactasItero::Api
+
+    attr_accessor :bearer_token
+
+    def initialize(options = {})
+      PactasItero::Configurable.keys.each do |key|
+        instance_variable_set(:"@#{key}", options[key] || PactasItero.instance_variable_get(:"@#{key}"))
+      end
+    end
+
+    def get(url, options = {})
+      request :get, url, options
+    end
+
+    def post(url, options = {})
+      request :post, url, options
+    end
+
+    def put(url, options = {})
+      request :put, url, options
+    end
+
+    def patch(url, options = {})
+      request :patch, url, options
+    end
+
+    def delete(url, options = {})
+      request :delete, url, options
+    end
+
+    def head(url, options = {})
+      request :head, url, options
+    end
+
+    def bearer_token?
+      !!bearer_token
+    end
+
+    private
+
+    def connection
+      @connection ||= Faraday.new(api_endpoint, connection_options)
+    end
+
+    def request(method, path, params = {})
+      headers = params.delete(:headers) || {}
+      if accept = params.delete(:accept)
+        headers[:accept] = accept
+      end
+
+      bearer_token_request = params.delete(:bearer_token_request)
+
+      if bearer_token_request
+        headers[:accept]        = '*/*'
+        headers[:authorization] = bearer_token_credentials_auth_header
+        headers[:content_type]  = 'application/x-www-form-urlencoded; charset=UTF-8'
+      else
+        headers[:authorization] = auth_header
+      end
+
+      response = connection.send(method.to_sym, path, params) {
+        |request| request.headers.update(headers)
+      }.env
+      response.body
+    end
+
+    def connection_options
+      @connection_options ||= {
+        :builder => middleware,
+        :headers => {
+          :accept => default_media_type,
+          :user_agent => user_agent,
+        },
+        :request => {
+          :open_timeout => 10,
+          :timeout => 30,
+        },
+      }
+    end
+
+    def bearer_token_credentials_auth_header
+      basic_auth_token = Base64.strict_encode64("#{@client_id}:#{@client_secret}")
+      "Basic #{basic_auth_token}"
+    end
+
+    def bearer_auth_header
+      token = if bearer_token.respond_to?(:access_token)
+        bearer_token.access_token
+      else
+        bearer_token
+      end
+      "Bearer #{token}"
+    end
+
+    def auth_header
+      @bearer_token = token unless bearer_token?
+      bearer_auth_header
+    end
+  end
+end

data/lib/pactas_itero/configurable.rb

@@ -0,0 +1,59 @@
+module PactasItero
+
+  module Configurable
+    attr_accessor :bearer_token, :client_id, :client_secret, :user_agent,
+                  :default_media_type, :middleware, :production
+    attr_writer :api_endpoint
+    class << self
+
+      # List of configurable keys for PactasItero::Client
+      def keys
+        @keys ||= [
+          :bearer_token,
+          :api_endpoint,
+          :client_id,
+          :client_secret,
+          :user_agent,
+          :default_media_type,
+          :middleware,
+          :production
+        ]
+      end
+    end
+
+    # Set configuration options using a block
+    def configure
+      yield self
+    end
+
+    # Reset configuration options to default values
+    def reset!
+      PactasItero::Configurable.keys.each do |key|
+        send(:"#{key}=", PactasItero::Default.options[key])
+      end
+      self
+    end
+    alias setup reset!
+
+    def api_endpoint
+      endpoint = @api_endpoint ||
+       production && production_api_endpoint ||
+       sandbox_api_endpoint
+      File.join(endpoint, "")
+    end
+
+    def sandbox_api_endpoint
+      PactasItero::Default.sandbox_api_endpoint
+    end
+
+    def production_api_endpoint
+      PactasItero::Default.production_api_endpoint
+    end
+
+    private
+
+    def options
+      Hash[PactasItero::Configurable.keys.map{|key| [key, send(:"#{key}")]}]
+    end
+  end
+end

data/lib/pactas_itero/default.rb

@@ -0,0 +1,77 @@
+require 'pactas_itero/response/raise_error'
+require 'pactas_itero/version'
+require 'faraday_middleware'
+
+module PactasItero
+
+  # Default configuration options for {Client}
+  module Default
+
+    SANDBOX_API_ENDPOINT = "https://sandbox.billwerk.com".freeze
+
+    PRODUCTION_API_ENDPOINT = "https://itero.pactas.com".freeze
+
+    PRODUCTION = false
+
+    USER_AGENT   = "Pactas.Itero Ruby Gem #{PactasItero::VERSION}".freeze
+
+    MEDIA_TYPE   = "application/json"
+
+    MIDDLEWARE = Faraday::RackBuilder.new do |builder|
+      builder.request :json
+      builder.use PactasItero::Response::RaiseError
+      builder.response :rashify
+      builder.request :url_encoded
+      builder.response :json, :content_type => /\bjson$/
+
+      builder.adapter Faraday.default_adapter
+    end
+
+    class << self
+
+      def options
+        Hash[PactasItero::Configurable.keys.map{|key| [key, send(key)]}]
+      end
+
+      def api_endpoint
+        ENV['PACTAS_ITERO_ENDPOINT']
+      end
+
+      def sandbox_api_endpoint
+        SANDBOX_API_ENDPOINT
+      end
+
+      def production_api_endpoint
+        PRODUCTION_API_ENDPOINT
+      end
+
+      def production
+        PRODUCTION
+      end
+
+      def client_id
+        ENV['PACTAS_ITERO_CLIENT_ID']
+      end
+
+      def client_secret
+        ENV['PACTAS_ITERO_CLIENT_SECRET']
+      end
+
+      def bearer_token
+        ENV['PACTAS_ITERO_BEARER_TOKEN']
+      end
+
+      def default_media_type
+        ENV['PACTAS_ITERO_CLIENT_DEFAULT_MEDIA_TYPE'] || MEDIA_TYPE
+      end
+
+      def middleware
+        MIDDLEWARE
+      end
+
+      def user_agent
+        ENV['PACTAS_ITERO_USER_AGENT'] || USER_AGENT
+      end
+    end
+  end
+end

data/lib/pactas_itero/error.rb

@@ -0,0 +1,217 @@
+module PactasItero
+  # Custom error class for rescuing from all Pactas errors
+  class Error < StandardError
+
+    # Returns the appropriate PactasItero::Error sublcass based
+    # on status and response message
+    #
+    # @param [Hash] response HTTP response
+    # @return [PactasItero::Error]
+    def self.from_response(response)
+      status  = response[:status].to_i
+      body    = response[:body].to_s
+      headers = response[:response_headers]
+
+      if klass =  case status
+                  when 400      then PactasItero::BadRequest
+                  when 401      then error_for_401(headers)
+                  when 403      then error_for_403(body)
+                  when 404      then PactasItero::NotFound
+                  when 406      then PactasItero::NotAcceptable
+                  when 409      then PactasItero::Conflict
+                  when 415      then PactasItero::UnsupportedMediaType
+                  when 422      then PactasItero::UnprocessableEntity
+                  when 400..499 then PactasItero::ClientError
+                  when 500      then PactasItero::InternalServerError
+                  when 501      then PactasItero::NotImplemented
+                  when 502      then PactasItero::BadGateway
+                  when 503      then PactasItero::ServiceUnavailable
+                  when 500..599 then PactasItero::ServerError
+                  end
+        klass.new(response)
+      end
+    end
+
+    def initialize(response=nil)
+      @response = response
+      super(build_error_message)
+    end
+
+    # Returns most appropriate error for 401 HTTP status code
+    # @private
+    def self.error_for_401(headers)
+      if PactasItero::OneTimePasswordRequired.required_header(headers)
+        PactasItero::OneTimePasswordRequired
+      else
+        PactasItero::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
+        PactasItero::TooManyRequests
+      elsif body =~ /login attempts exceeded/i
+        PactasItero::TooManyLoginAttempts
+      else
+        PactasItero::Forbidden
+      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 do |hash|
+        hash.map { |k,v| "  #{k}: #{v}" }
+      end.join("\n")
+
+      summary
+    end
+
+    def build_error_message
+      return nil if @response.nil?
+
+      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
+    end
+
+    def redact_url(url_string)
+      %w[client_secret access_token].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 Pactas returns a 400 HTTP status code
+  class BadRequest < ClientError; end
+
+  # Raised when Pactas returns a 401 HTTP status code
+  class Unauthorized < ClientError; end
+
+  # Raised when Pactas returns a 401 HTTP status code
+  # and headers include "X-Pactas-OTP"
+  class OneTimePasswordRequired < ClientError
+    #@private
+    OTP_DELIVERY_PATTERN = /required; (\w+)/i
+
+    #@private
+    def self.required_header(headers)
+      OTP_DELIVERY_PATTERN.match headers['X-Pactas-OTP'].to_s
+    end
+
+    # Delivery method for the user's OTP
+    #
+    # @return [String]
+    def password_delivery
+      @password_delivery ||= delivery_method_from_header
+    end
+
+    private
+
+    def delivery_method_from_header
+      if match = self.class.required_header(@response[:response_headers])
+        match[1]
+      end
+    end
+  end
+
+  # Raised when Pactas returns a 403 HTTP status code
+  class Forbidden < ClientError; end
+
+  # Raised when Pactas returns a 403 HTTP status code
+  # and body matches 'rate limit exceeded'
+  class TooManyRequests < Forbidden; end
+
+  # Raised when Pactas returns a 403 HTTP status code
+  # and body matches 'login attempts exceeded'
+  class TooManyLoginAttempts < Forbidden; end
+
+  # Raised when Pactas returns a 404 HTTP status code
+  class NotFound < ClientError; end
+
+  # Raised when Pactas returns a 406 HTTP status code
+  class NotAcceptable < ClientError; end
+
+  # Raised when Pactas returns a 409 HTTP status code
+  class Conflict < ClientError; end
+
+  # Raised when Pactas returns a 414 HTTP status code
+  class UnsupportedMediaType < ClientError; end
+
+  # Raised when Pactas returns a 422 HTTP status code
+  class UnprocessableEntity < ClientError; end
+
+  # Raised on errors in the 500-599 range
+  class ServerError < Error; end
+
+  # Raised when Pactas returns a 500 HTTP status code
+  class InternalServerError < ServerError; end
+
+  # Raised when Pactas returns a 501 HTTP status code
+  class NotImplemented < ServerError; end
+
+  # Raised when Pactas returns a 502 HTTP status code
+  class BadGateway < ServerError; end
+
+  # Raised when Pactas returns a 503 HTTP status code
+  class ServiceUnavailable < ServerError; end
+
+  # Raised when client fails to provide valid Content-Type
+  class MissingContentType < ArgumentError; end
+
+  # Raised when a method requires an application client_id
+  # and secret but none is provided
+  class ApplicationCredentialsRequired < StandardError; end
+end

data/lib/pactas_itero/ext/hash/camelize_keys.rb

@@ -0,0 +1,32 @@
+class Hash
+
+  def camelize_keys(value = self)
+    case value
+      when Array
+        value.map { |v| camelize_keys(v) }
+      when Hash
+        Hash[value.map { |k, v| [camelize_key(k), camelize_keys(v)] }]
+      else
+        value
+    end
+  end
+
+  private
+
+  def camelize_key(key)
+    if key.is_a? Symbol
+      camelize(key.to_s).to_sym
+    elsif key.is_a? String
+      camelize(key)
+    else
+      key
+    end
+  end
+
+  # copied from ActiveSupport
+  def camelize(term)
+    string = term.to_s
+    string = string.sub(/^[a-z\d]*/) { $&.capitalize }
+    string.gsub(/(?:_|(\/))([a-z\d]*)/) { "#{$1}#{$2.capitalize}" }.gsub('/', '::')
+  end
+end

data/lib/pactas_itero/response/raise_error.rb

@@ -0,0 +1,21 @@
+require 'faraday'
+require 'pactas_itero/error'
+
+module PactasItero
+  # Faraday response middleware
+  module Response
+
+    # This class raises an PactasItero-flavored exception based
+    # HTTP status codes returned by the API
+    class RaiseError < Faraday::Response::Middleware
+
+      private
+
+      def on_complete(response)
+        if error = PactasItero::Error.from_response(response)
+          raise error
+        end
+      end
+    end
+  end
+end

data/lib/pactas_itero/version.rb

@@ -0,0 +1,3 @@
+module PactasItero
+  VERSION = "0.2.0".freeze
+end

data/lib/pactas_itero.rb

@@ -0,0 +1,31 @@
+require 'pactas_itero/client'
+require 'pactas_itero/default'
+
+module PactasItero
+
+  class << self
+    include PactasItero::Configurable
+
+    # API client based on configured options {Configurable}
+    #
+    # @return [PactasItero::Client] API wrapper
+    def client
+      @client = PactasItero::Client.new(options)
+      @client
+    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"
+
+  private
+
+    def method_missing(method_name, *args, &block)
+      return super unless client.respond_to?(method_name)
+      client.send(method_name, *args, &block)
+    end
+  end
+end
+
+PactasItero.setup

data/pactas_itero.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'pactas_itero/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'pactas_itero'
+  spec.version       = PactasItero::VERSION
+  spec.authors       = ['Simon Fröhler']
+  spec.email         = "simon@shipcloud.io"
+  spec.summary       = %q{pactas_itero provides a client mapping for accessing
+    the Pactas Itero API.}
+  spec.description   = %q{pactas_itero provides a client mapping for accessing
+    the Pactas Itero API, making it easy to post your data to, adn read your
+    data from your Pactas account.}
+  spec.homepage      = 'https://github.com/webionate/pactas_itero'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files`.split("\n")
+  spec.test_files    = `git ls-files -- spec/*`.split("\n")
+  spec.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency('faraday_middleware', '~> 0.9.1')
+  spec.add_dependency('rash', '~> 0.4.0')
+
+  spec.add_development_dependency 'bundler', '~> 1.7'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency "rspec", '~> 3.0'
+  spec.add_development_dependency("simplecov", "~> 0")
+  spec.add_development_dependency("webmock", "~> 1.18", ">= 1.18.0")
+end

data/spec/fixtures/bearer_token.json

@@ -0,0 +1,5 @@
+{
+  "access_token": "top_secret_access_token",
+  "expires": 0,
+  "token_type": "bearer"
+}

data/spec/fixtures/commit_order_response.json

@@ -0,0 +1,50 @@
+{
+  "Id": "5370e5ab9e40071fd01e01e0",
+  "LastBillingDate": "2014-05-22T13:33:30.9510000Z",
+  "NextBillingDate": "2014-06-22T13:33:30.9510000Z",
+  "PlanId": "525bf8eb9e40073a58590fd4",
+  "CustomerId": "5370e5ab9e40071fd01e01df",
+  "LifecycleStatus": "Active",
+  "CustomerName": "asd asd",
+  "Phases": [{
+    "Type": "Normal",
+    "StartDate": "2014-05-12T15:15:55.8410000Z",
+    "PlanVariantId": "5256be5c9e4007398ce610f0",
+    "PlanId": "5256be2a9e4007398ce610ef"
+  }, {
+    "Type": "Inactive",
+    "StartDate": "2014-05-13T22:00:00.0000000Z"
+    }, {
+    "Type": "Normal",
+    "StartDate": "2014-05-22T13:22:41.4510000Z",
+    "PlanVariantId": "5256be5c9e4007398ce610f0",
+    "PlanId": "5256be2a9e4007398ce610ef"
+  }, {
+    "Type": "Normal",
+    "StartDate": "2014-05-22T13:33:30.9510000Z",
+    "PlanVariantId": "525bf9089e40073a58590fd5",
+    "PlanId": "525bf8eb9e40073a58590fd4"
+  }],
+  "Balance": 0,
+  "Currency": "EUR",
+  "PlanGroupId": "5256be1b9e4007398ce610ee",
+  "PaymentBearer": {
+    "Code": "41212312",
+    "Holder": "asdasd asdad",
+    "Country": "de",
+    "Account": "*****3123",
+    "Type": "BankAccount"
+  },
+  "PaymentProvider": "Paymill",
+  "EscalationSuspended": false,
+  "RecurringPaymentsPaused": false,
+  "CurrentPhase": {
+    "Type": "Normal",
+    "StartDate": "2014-05-22T13:33:30.9510000Z",
+    "PlanVariantId": "525bf9089e40073a58590fd5",
+    "PlanId": "525bf8eb9e40073a58590fd4"
+  },
+  "StartDate": "2014-05-12T15:15:55.8410000Z",
+  "BilledUntil": "2014-06-22T13:33:30.9510000Z",
+  "PlanVariantId": "525bf9089e40073a58590fd5"
+}

data/spec/fixtures/contract.json

@@ -0,0 +1,46 @@
+{
+  "Balance": 0,
+  "BilledUntil": "2014-05-23T13:12:47.0760000Z",
+  "Currency": "EUR",
+  "CurrentPhase": {
+      "PlanId": "53567a9e1d8dd00df056564d",
+      "PlanVariantId": "53567b431d8dd00df056564f",
+      "StartDate": "2014-04-23T13:12:47.0760000Z",
+      "Type": "Normal"
+  },
+  "CustomerId": "5357bc4f1d8dd00fa0db6c31",
+  "CustomerName": "Max Mustermann",
+  "EndDate": "2014-05-23T13:12:47.0760000Z",
+  "EscalationSuspended": false,
+  "Id": "5357bc4f1d8dd00fa0db6c32",
+  "LastBillingDate": "2014-04-23T13:12:47.0760000Z",
+  "LifecycleStatus": "Active",
+  "NextBillingDate": "2014-05-23T13:12:47.0760000Z",
+  "PaymentBearer": {
+      "CardType": "visa",
+      "Country": "DE",
+      "ExpiryMonth": 12,
+      "ExpiryYear": 2017,
+      "Holder": "Marcellus Wallace",
+      "Last4": "1111",
+      "Type": "CreditCard"
+  },
+  "PaymentProvider": "Paymill",
+  "Phases": [
+      {
+          "PlanId": "53567a9e1d8dd00df056564d",
+          "PlanVariantId": "53567b431d8dd00df056564f",
+          "StartDate": "2014-04-23T13:12:47.0760000Z",
+          "Type": "Normal"
+      },
+      {
+          "StartDate": "2014-05-23T13:12:47.0760000Z",
+          "Type": "Inactive"
+      }
+  ],
+  "PlanGroupId": "53567a731d8dd00df056564a",
+  "PlanId": "53567a9e1d8dd00df056564d",
+  "PlanVariantId": "53567b431d8dd00df056564f",
+  "RecurringPaymentsPaused": false,
+  "StartDate": "2014-04-23T13:12:47.0760000Z"
+}