currency_cloud 0.5

data/lib/currency_cloud/pagination.rb

@@ -0,0 +1,7 @@
+module CurrencyCloud
+  
+  class Pagination < OpenStruct
+    
+  end
+  
+end

data/lib/currency_cloud/request_handler.rb

@@ -0,0 +1,68 @@
+module CurrencyCloud
+
+  class RequestHandler
+    
+    attr_reader :session
+    
+    def initialize(session = CurrencyCloud.session)
+      @session = session
+    end
+    
+    def get(route, params={}, opts={})
+      retry_authenticate('get', route, params, opts) do |url, options|
+        HTTParty.get(url, options)
+      end
+    end
+    
+    def post(route, params={}, opts={})
+      retry_authenticate('post', route, params, opts) do |url, options|
+        HTTParty.post(url, options)
+      end
+    end
+
+    private
+    def retry_authenticate(verb, route, params, opts)
+      should_retry = opts[:should_retry].nil? ? true : opts.delete(:should_retry)
+      description = "to #{verb}: #{route}"
+      
+      options = process_options(verb, params, opts)
+
+      response = nil
+      retry_count = should_retry ? 0 : 2
+      while retry_count < 3
+        response = yield(full_url(route), options)
+        break unless response.code == 401 && should_retry
+        session.reauthenticate
+        retry_count += 1
+      end
+      
+      process_response(response)
+    rescue => e
+      raise if e.class.ancestors.include?(ApiError) || e.is_a?(UnexpectedError)
+      raise UnexpectedError.new(e)
+    end
+
+    def process_options(verb, params, opts)
+      options = {:headers => headers }
+      params_key = verb == :get ? :query : :body
+      options[params_key] = params
+      options.merge!(opts)
+      # options[:debug_output] = $stdout
+      options
+    end
+
+    def headers
+      headers = {}
+      headers['X-Auth-Token'] = session.token if session.token
+      headers
+    end
+        
+    def full_url(route)
+      "#{session.environment_url}/#{CurrencyCloud::ApiVersion}/" + route
+    end
+    
+    def process_response(response)
+      CurrencyCloud::ResponseHandler.process(response)
+    end
+  end
+end

data/lib/currency_cloud/resource.rb

@@ -0,0 +1,73 @@
+require 'set'
+
+module CurrencyCloud
+
+  class Resource
+  
+    def self.resource(resource=nil)
+      @resource ||= resource
+    end
+    
+    def self.actions(*actions)
+      @actions ||= actions
+      @actions.each do |action|
+        self.class_eval do # self.class.instance_eval # metaclass.instance_eval
+          action_module = CurrencyCloud::Actions.const_get(action.to_s.capitalize)
+          self.extend(action_module)
+        end
+      end
+    end
+    
+    def initialize(object)
+      @object = object
+      @changed_attributes = Set.new
+      set_accessors(keys)
+    end
+    
+    def keys
+      @object.keys
+    end
+
+    def inspect
+      "#<#{self.class}:0x#{self.object_id.to_s(16)} #{@object.inspect}>"
+    end
+    
+    private
+
+    def changed?
+      !@changed_attributes.empty?
+    end
+    
+    def metaclass
+      class << self; self; end
+    end
+    
+    def set_accessors(keys)
+      metaclass.instance_eval do
+        keys.each do |key|
+          define_method(key) { @object[key] }
+          define_method("#{key}=".to_sym) do |value|
+            @object[key] = value
+            @changed_attributes << key
+          end
+        end
+      end
+    end
+
+    def self.get(url, params={})
+      new(request.get(build_url(url), params))
+    end
+
+    def self.post(url, params={})
+      new(request.post(build_url(url), params))
+    end
+
+    def self.build_url(url)
+      "#{self.resource}/#{url}"
+    end
+
+    def self.request
+      RequestHandler.new
+    end
+  end
+end

data/lib/currency_cloud/resourceful_collection.rb

@@ -0,0 +1,15 @@
+module CurrencyCloud
+  class ResourcefulCollection
+    include Enumerable
+    
+    extend Forwardable
+    def_delegators :@collection, :[], :length, :empty?, :each
+
+    attr_reader :pagination
+
+    def initialize(resource, klass, collection)
+      @collection = collection[resource.to_s].map { |object| klass.new(object) }
+      @pagination = Pagination.new(collection['pagination'])
+    end
+  end  
+end

data/lib/currency_cloud/resources/account.rb

@@ -0,0 +1,6 @@
+module CurrencyCloud
+  class Account < Resource
+    resource :accounts
+    actions :create, :retrieve, :find, :update, :current
+  end
+end

data/lib/currency_cloud/resources/balance.rb

@@ -0,0 +1,8 @@
+module CurrencyCloud
+  class Balance < Resource
+    resource :balances
+    actions :find
+
+    #TODO: currency
+  end
+end

data/lib/currency_cloud/resources/beneficiary.rb

@@ -0,0 +1,14 @@
+module CurrencyCloud
+  
+  class Beneficiary < Resource
+    
+    resource :beneficiaries
+    
+    actions :create, :retrieve, :find, :update, :delete
+    
+    def self.validate(params)
+      new(request.get("#{self.resource}/validate", params))
+    end
+        
+  end
+end

data/lib/currency_cloud/resources/contact.rb

@@ -0,0 +1,6 @@
+module CurrencyCloud
+  class Contact < Resource
+    resource :contacts
+    actions :create, :retrieve, :find, :update, :current
+  end
+end

data/lib/currency_cloud/resources/conversion.rb

@@ -0,0 +1,10 @@
+module CurrencyCloud
+  
+  class Conversion < Resource
+    
+    resource :conversions
+    
+    actions :create, :retrieve, :find
+
+  end
+end

data/lib/currency_cloud/resources/payer.rb

@@ -0,0 +1,6 @@
+module CurrencyCloud
+  class Payer < Resource
+    resource :payers
+    actions :retrieve
+  end
+end

data/lib/currency_cloud/resources/payment.rb

@@ -0,0 +1,11 @@
+module CurrencyCloud
+  
+  class Payment < Resource
+    
+    resource :payments
+    
+    actions :create, :retrieve, :find, :delete, :update
+    
+    #TODO: authorize, authorizations
+  end
+end

data/lib/currency_cloud/resources/rate.rb

@@ -0,0 +1,21 @@
+module CurrencyCloud
+  class Rates < Resource; end
+
+  class Rate < Resource
+    resource :rates
+    
+    def self.find(params)
+      response = request.get("#{self.resource}/find", params)
+
+      rates = response['rates'].map do |currency_pair, bid_offer|
+                new(currency_pair: currency_pair, bid: bid_offer[0], offer: bid_offer[1])
+              end
+
+      Rates.new(currencies: rates, unavailable: response['unavailable'])
+    end
+
+    def self.detailed(params)
+      get('detailed', params)
+    end
+  end
+end

data/lib/currency_cloud/resources/reference.rb

@@ -0,0 +1,29 @@
+module CurrencyCloud
+  
+  class Currency < Resource; end
+  class ConversionDates < Resource; end
+  class SettlementAccount < Resource; end
+
+  class Reference < Resource
+    
+    resource :reference
+
+    def self.currencies
+      response = request.get(build_url("currencies"))
+      response['currencies'].map { |c| Currency.new(c)}
+    end
+
+    def self.beneficiary_required_details(params={})
+      request.get(build_url("beneficiary_required_details"), params)['details']
+    end
+
+    def self.conversion_dates(params)
+      ConversionDates.new(request.get(build_url("conversion_dates"), params))
+    end
+
+    def self.settlement_accounts(params={})
+      response = request.get(build_url("settlement_accounts"), params)
+      response['settlement_accounts'].map { |s| SettlementAccount.new(s)}
+    end
+  end
+end

data/lib/currency_cloud/resources/settlement.rb

@@ -0,0 +1,30 @@
+module CurrencyCloud
+  
+  class Settlement < Resource
+    
+    resource :settlements
+    
+    actions :create, :retrieve, :find, :delete
+    
+    def add_conversion(conversion_id)
+      # TODO: Should just update state of current object using a refresh method?
+      new(request.post("#{self.resource}/#{self.id}/add_conversion", conversion_id: conversion_id))
+    end
+    
+    def remove_conversion(conversion_id)
+      # TODO: Should just update state of current object using a refresh method?
+      new(request.post("#{self.resource}/#{self.id}/remove_conversion", conversion_id: conversion_id)) 
+    end
+    
+    def release
+      # TODO: Should just update state of current object using a refresh method?
+      new(request.post("#{self.resource}/#{self.id}/release")) 
+    end
+    
+    def unrelease
+      # TODO: Should just update state of current object using a refresh method?
+      new(request.post("#{self.resource}/#{self.id}/unrelease")) 
+    end
+    
+  end
+end

data/lib/currency_cloud/resources/transaction.rb

@@ -0,0 +1,7 @@
+module CurrencyCloud
+  class Transaction < Resource
+    resource :transactions
+    
+    actions :retrieve, :find
+  end
+end

data/lib/currency_cloud/response_handler.rb

@@ -0,0 +1,46 @@
+module CurrencyCloud
+  
+  class ResponseHandler
+    
+    attr_reader :response
+    
+    def self.process(response)
+      new(response).data
+    end
+    
+    def initialize(response)
+      @response = response
+    end
+    
+    def data
+      if success?
+        return parsed_response
+      else
+        handle_failure
+      end
+    end
+    
+    private
+    
+    def success?
+      [200, 202].include?(response.code)
+    end
+    
+    def handle_failure
+      error_class = case response.code
+        when 400 then CurrencyCloud::BadRequestError
+        when 401 then CurrencyCloud::AuthenticationError
+        when 403 then CurrencyCloud::ForbiddenError
+        when 404 then CurrencyCloud::NotFoundError
+        when 429 then CurrencyCloud::TooManyRequestsError
+        when 500 then CurrencyCloud::InternalApplicationError
+        else CurrencyCloud::UnexpectedError
+      end
+      raise error_class.new(response)
+    end
+    
+    def parsed_response
+      @parsed_response ||= JSON.parse(response.body)
+    end
+  end
+end

data/lib/currency_cloud/session.rb

@@ -0,0 +1,62 @@
+module CurrencyCloud    
+
+  class Session
+    
+    Environments = { :production => 'https://api.thecurrencycloud.com',
+                     :demonstration => 'https://devapi.thecurrencycloud.com',
+                     :uat => 'https://api-uat1.ccycloud.com'}
+   
+    attr_reader :environment, :login_id, :api_key
+    attr_accessor :token
+    
+    def self.validate_environment(environment)
+      unless Environments.keys.include?(environment)
+        raise CurrencyCloud::ConfigError, "'#{environment}' is not a valid environment, must be one of: #{Environments.keys.join(", ")}"
+      end
+    end
+   
+    def initialize(environment, login_id, api_key, token)
+      @environment = environment
+      @login_id = login_id
+      @api_key = api_key
+      
+      if token
+        self.class.validate_environment(environment)
+        @token = token
+      else
+        authenticate
+      end
+    end
+    
+    def environment_url
+      Environments[environment]
+    end
+
+    def close
+      request.post('authenticate/close_session')
+    end
+    
+    
+    def authenticate
+      validate
+      params = {:login_id => login_id, :api_key => api_key}
+      @token = request.post('authenticate/api', params, :should_retry => false)['auth_token']
+    end
+
+    def reauthenticate
+      token = nil
+      authenticate
+    end
+    
+    private
+    def validate
+      self.class.validate_environment(environment)
+      raise CurrencyCloud::ConfigError, "login_id must be set using CurrencyCloud.login_id=" unless login_id
+      raise CurrencyCloud::ConfigError, "api_key must be set using CurrencyCloud.api_key=" unless api_key
+    end
+    
+    def request
+      RequestHandler.new(self)
+    end
+  end
+end