ribbon-flow 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 07298ede14e9864a03a7e433a43b9e387c540ee1
+  data.tar.gz: 757937ae1b637a82724df958ab7b6a0a641889dc
+SHA512:
+  metadata.gz: a3950406361a0e8ac3f0e5ef27e3103466115a54ee6ab4dfd4dac89b34407a670ea5f9b7423ec03e98e8fd15064a1602bbcab940c859703afd7d1269b1fc637c
+  data.tar.gz: c1555ebc95da219a0f1d2b65b155039a49f8741eccd53d7086f712bb4fff39ecea6bf3248b051de1cff6a4fc6736c703d7b82ef2341f8469c7a7f07a6caa7feb

data.tar.gz.sig

@@ -0,0 +1,2 @@
+���)�&4��2�?A��	��/��7�B����"I:���~�_u���ր��lh�ͷ���z�w�)c���d3p
y��5PK��^�Y�6}�
+�j��Sp�;�+����:��GY��%���	�#��'0C�uxF�e��Ԩ5��%Y�E��V&�\���W�v��z. �x^�\��ɩ�U}m�Z�

data/lib/flow.rb

@@ -0,0 +1,31 @@
+
+require 'flow/version'
+require 'flow/errors'
+require 'flow/config'
+require 'flow/connection'
+require 'flow/models'
+require 'flow/response'
+
+module Flow
+
+  def self.config
+    Flow::Config.instance
+  end
+
+  def self.connection
+    @__connection_cache ||= Flow::Connection.new(config.api_key, config.url)
+  end
+
+  def self.pool(pool_token)
+    Flow::Models::Pool.load(connection, pool_token)
+  end
+
+  def self.card(card_token)
+    Flow::Models::Card.load(connection, card_token)
+  end
+
+  def self.transaction(transaction_token)
+    Flow::Models::Transaction.load(connection, transaction_token)
+  end
+
+end

data/lib/flow/config.rb

@@ -0,0 +1,50 @@
+
+require 'singleton'
+
+module Flow
+  class Config
+    include Singleton
+
+    def initialize
+      @config = self.defaults
+    end
+
+    def defaults
+      {
+        url: 'https://flow.ribbon.co'.freeze,
+        api_key: nil
+      }
+    end
+
+    def method_missing(meth, *args, &block)
+      meth_str = meth.to_s
+
+      if /^(\w+)=$/.match(meth_str)
+        _set($1, args.first)
+      else
+        _get(meth)
+      end
+    end
+
+    def url=(url)
+      url = url[0..-2] if url[-1] == '/' # No trailing forward-slash
+      _set(:url, url)
+    end
+
+    def to_s
+      return @config.to_s
+    end
+
+    private
+
+    def _set(key, value)
+      # Changing the config value should require calling the
+      # _set method again.
+      return @config[key.to_sym] = value.dup.freeze
+    end
+
+    def _get(key)
+      return @config[key.to_sym]
+    end
+  end
+end

data/lib/flow/connection.rb

@@ -0,0 +1,187 @@
+
+require 'rest-client'
+require 'openssl'
+require 'securerandom'
+
+module Flow
+
+  class Connection
+    attr_reader :url
+    attr_reader :access_key
+    attr_reader :version
+
+    attr_reader :scheme
+    attr_reader :host
+    attr_reader :port
+
+    def initialize(api_key, url='https://flow.ribbon.co', version=1)
+      @version = version
+
+      @url = (url[-1] == '/' ? url[0..-2] : url).dup.freeze # Remove trailing slash.
+
+      if /^([A-Za-z0-9]{20})\.([A-Za-z0-9]{43})$/.match(api_key)
+        @access_key = $1.dup.freeze
+        @signing_key = $2.dup.freeze
+      else
+        raise Flow::Errors::ConnectionError, "Invalid API Key format."
+      end
+
+      URI.parse(@url).tap do |uri|
+        @scheme = uri.scheme
+        @host = uri.host
+        @port = uri.port
+      end
+
+      # RestClient::Resource.new(
+      #   'https://example.com',
+      #   :ssl_client_cert  =>  OpenSSL::X509::Certificate.new(File.read("cert.pem")),
+      #   :ssl_client_key   =>  OpenSSL::PKey::RSA.new(File.read("key.pem"), "passphrase, if any"),
+      #   :ssl_ca_file      =>  "ca_certificate.pem",
+      #   :verify_ssl       =>  OpenSSL::SSL::VERIFY_PEER
+      # )
+
+      @api = RestClient::Resource.new(
+        @url,
+        verify_ssl: true,
+        headers: {
+          "Content-Type" => "application/json"
+        }
+      ) {|response, request, result| response}
+    end
+
+    def get(path, params={})
+      path = _build_path(path)
+      auth_header = _authorization_header(:get, path, params)
+      response = @api[path].get(authorization: auth_header, params: params)
+      Flow::Response.new(self, response)
+    end
+
+    def post(path, params={}, &block)
+      if block_given?
+        body_hash = block.call
+        if body_hash && !body_hash.empty?
+          body = body_hash.to_json
+        end
+      end
+
+      path = _build_path(path)
+      auth_header = _authorization_header(:post, path, params, body)
+      response = @api[path].post(body, authorization: auth_header, params: params)
+      
+      Flow::Response.new(self, response)
+    end
+
+    private
+    
+    def _signing_key
+      @signing_key
+    end
+
+    def _build_path(path)
+      path = '/' + path unless path[0] == '/'
+
+      if path.start_with?('/api/')
+        return path
+      else
+        return "/api/v#{version}#{path}"
+      end
+    end
+
+    def _gen_nonce
+      begin
+        nonce = SecureRandom.hex(8)
+      end until _valid_nonce?(nonce)
+
+      return nonce.freeze
+    end
+
+    def _valid_nonce?(nonce)
+      record = @__nonce_record ||= {}
+      nonce = nonce.to_s
+
+      # Try to limit the record store to about 2MB
+      # of data, assuming 16 single-byte characters 
+      # and 4 byte timestamps.
+      # Supports 3,333 requests per second before exceeding
+      # the limit.
+      if record.length > 100_000
+        threshold_ts = (Time.now.to_i - 30).freeze
+        record.delete_if {|k,v| v < threshold_ts}
+      end
+
+      if record[nonce] && record[nonce] >= (Time.now.to_i - 30)
+        return false
+      else
+        record[nonce] = Time.now.to_i.freeze
+        return true
+      end
+    end
+
+    def _authorization_header(verb, path, query_hash, body=nil)
+      timestamp = Time.now.to_i.freeze
+      nonce = _gen_nonce
+
+      # Calculate request hash
+      path = _uri_encode(path[0] == '/' ? path : ('/' + path), false)
+      query_string = _hash_to_query_string(query_hash)
+      body_hash = _sha256(body.to_s)
+      request_hash = _sha256(
+        verb.to_s.upcase + "\n" +
+        host + "\n" +
+        path + "\n" +
+        query_string + "\n" +
+        body_hash
+      )
+
+      # Construct the message
+      message = timestamp.to_s + nonce + request_hash
+
+      signature = _hmac_sha256_hex(_signing_key, message)
+
+      return "RBN1-HMAC-SHA256 #{access_key};#{timestamp};#{nonce};#{signature}"
+    end
+
+    ######################################################################
+    #
+    # Encoding and signing helper methods
+    #
+    ######################################################################
+
+    def _hmac_sha256_hex(key, message)
+      digest = OpenSSL::Digest::SHA256.new
+      OpenSSL::HMAC.hexdigest(digest, key, message)
+    end
+
+    def _sha256(str)
+      ::OpenSSL::Digest::SHA256.hexdigest(str)
+    end
+
+    def _uri_encode(string, encode_fslash=true)
+      retval = ""
+
+      string.chars.each do |ch|
+        if (ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z') ||
+           (ch >= '0' && ch <= '9') || ch == '-' || ch == '_' || ch == '.' || ch == '~'
+          retval << ch
+        elsif ch == '/'
+          retval << (encode_fslash ? '%2F' : ch)
+        else
+          retval << '%' << ch.bytes.first.to_s(16).upcase
+        end
+      end
+      
+      return retval
+    end
+
+    def _hash_to_query_string(data)
+      pairs = []
+
+      data.sort{|a,b| a[0] <=> b[0]}.each do |key, value|
+        pairs << (_uri_encode(key.to_s) << '=' << _uri_encode(value.to_s))
+      end
+
+      pairs.join('&')
+    end
+  end
+
+end

data/lib/flow/errors.rb

@@ -0,0 +1,12 @@
+
+
+module Flow
+  module Errors
+
+    class FlowError < StandardError; end
+    class ConnectionError < FlowError; end
+    class ResponseError < FlowError; end
+    class LoadError < FlowError; end
+
+  end
+end

data/lib/flow/models.rb

@@ -0,0 +1,4 @@
+require 'flow/models/model'
+require 'flow/models/pool'
+require 'flow/models/card'
+require 'flow/models/transaction'

data/lib/flow/models/card.rb

@@ -0,0 +1,39 @@
+module Flow
+  module Models
+    class Card < Model
+
+      def self.load(connection, card_token)
+        r = connection.get("cards/#{card_token}")
+
+        raise Flow::Errors::LoadError.new(r.message) unless r.success?
+
+        return r.card
+      end
+
+      def ready?
+        self.status == 'ready'
+      end
+
+      def supported?
+        self.ready?
+      end
+
+      def unsupported?
+        self.status == 'unsupported'
+      end
+
+      def credit!(amount, options={})
+        r = connection.post("cards/#{self.token}/credits") do
+          {
+            amount: amount
+          }
+        end
+
+        raise Flow::Errors::ResponseError.new(r.message) unless r.success?
+
+        r.transaction
+      end
+
+    end
+  end
+end

data/lib/flow/models/model.rb

@@ -0,0 +1,40 @@
+
+module Flow
+  module Models
+
+    class Model
+      attr_reader :model_hash
+      attr_reader :connection
+
+      def initialize(connection, model_hash)
+        @connection = connection
+        @model_hash = model_hash
+      end
+
+      def method_missing(meth, *args, &block)
+        if model_hash.key?(meth.to_s)
+          return Model.load_model(meth, connection, model_hash[meth.to_s])
+        end
+
+        super
+      end
+
+      def self.load_model(name, connection, model_hash)
+        name = name.to_sym
+
+        case name
+        when :pool
+          return Flow::Models::Pool.new(connection, model_hash)
+        when :card
+          return Flow::Models::Card.new(connection, model_hash)
+        when :transaction
+          return Flow::Models::Transaction.new(connection, model_hash)
+        else
+          return model_hash
+        end
+      end
+
+    end
+
+  end
+end

data/lib/flow/models/pool.rb

@@ -0,0 +1,15 @@
+module Flow
+  module Models
+    class Pool < Model
+      
+      def self.load(connection, pool_token)
+        r = connection.get("pools/#{pool_token}")
+
+        raise Flow::Errors::LoadError.new(r.message) unless r.success?
+
+        return r.pool
+      end
+
+    end
+  end
+end

data/lib/flow/models/transaction.rb

@@ -0,0 +1,35 @@
+module Flow
+  module Models
+    class Transaction < Model
+
+      def self.load(connection, tx_token)
+        r = connection.get("transactions/#{tx_token}")
+
+        raise Flow::Errors::LoadError.new(r.message) unless r.success?
+
+        return r.transaction
+      end
+
+      def pending?
+        self.status == 'pending'
+      end
+
+      def scheduled?
+        self.status == 'scheduled'
+      end
+
+      def cleared?
+        self.status == 'cleared'
+      end
+
+      def failed?
+        self.status == 'failed'
+      end
+
+      def error?
+        self.status == 'error'
+      end
+      
+    end
+  end
+end

data/lib/flow/response.rb

@@ -0,0 +1,58 @@
+
+require 'json'
+
+module Flow
+
+  class Response
+    attr_reader :body
+    attr_reader :connection
+
+    def initialize(connection, rest_client_response)
+      @connection = connection
+      @response = rest_client_response
+
+      begin
+        body = @response.body
+        @body = JSON.parse(body) unless body.empty?
+        @body ||= {}
+        _deep_freeze(@body)
+      rescue JSON::ParserError => e
+        raise Flow::Errors::ResponseError, "Invalid JSON returned: #{e.message}"
+      end
+    end
+
+    def http_success?
+      @response.code >= 200 && @response.code < 300
+    end
+
+    def success?
+      body['status'] == 'success'
+    end
+
+    def error?
+      body['status'] == 'error'
+    end
+
+    def method_missing(meth, *args, &block)
+      if body.key?(meth.to_s)
+        return Flow::Models::Model.load_model(meth, connection, body[meth.to_s])
+      end
+
+      super
+    end
+
+
+    private
+
+    def _deep_freeze(obj)
+      if obj.respond_to?(:each)
+        obj.each do |elem|
+          _deep_freeze(elem)
+        end
+      end
+
+      obj.freeze
+    end
+  end
+
+end

data/lib/flow/version.rb

@@ -0,0 +1,4 @@
+
+module Flow
+  VERSION = '0.0.1'
+end

metadata

@@ -0,0 +1,92 @@
+--- !ruby/object:Gem::Specification
+name: ribbon-flow
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Robert Honer
+autorequire: 
+bindir: bin
+cert_chain:
+- |
+  -----BEGIN CERTIFICATE-----
+  MIIDfDCCAmSgAwIBAgIBATANBgkqhkiG9w0BAQUFADBCMRQwEgYDVQQDDAtlbmdp
+  bmVlcmluZzEWMBQGCgmSJomT8ixkARkWBnJpYmJvbjESMBAGCgmSJomT8ixkARkW
+  AmNvMB4XDTE0MDYwOTE2MjY0NFoXDTE1MDYwOTE2MjY0NFowQjEUMBIGA1UEAwwL
+  ZW5naW5lZXJpbmcxFjAUBgoJkiaJk/IsZAEZFgZyaWJib24xEjAQBgoJkiaJk/Is
+  ZAEZFgJjbzCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAOqAiBev9e7J
+  D3X3A+SXpIbnG71jweN7Q7+QMhscA6+s8X91aG2cvNPpk7OSMaoU7Q81v+I9VMYu
+  n0JhOh/O86nYv0Ig/FKcDRzZIGgY0bjJV/5mokQ45xgseUTjJ3ocqOXncRPNx4xm
+  Am3eyb43aDqUFnowXcH84ZXMTFew+dekov6644pN14u8aXGWPmZxOQhTOi5+ESAe
+  +RON7v2xRq1OFcupEHeKHMhAMCbOy19NqTq/1yA8Pd940OfVRisCnXoQqOCP9H86
+  gakm8XcLrUdJupV6OxCMd5NZ3itRTFEWOMy6ZRkj2IVdFQ4ZPQjIHR2f253DF7BW
+  dUStbmkKuyECAwEAAaN9MHswCQYDVR0TBAIwADALBgNVHQ8EBAMCBLAwHQYDVR0O
+  BBYEFPjdKqT6jDUZj755LAOopw41RGO/MCAGA1UdEQQZMBeBFWVuZ2luZWVyaW5n
+  QHJpYmJvbi5jbzAgBgNVHRIEGTAXgRVlbmdpbmVlcmluZ0ByaWJib24uY28wDQYJ
+  KoZIhvcNAQEFBQADggEBACmYnS5b0mBhurs/U+oTUiY6nL4/xTx1poZxUNJ9Emag
+  y/vnnbMxiZXXz4Y6vWdFiOg02N6BiBrvyjzkleOyw41lcNDj9pH6HyLFAKR4lU5V
+  HKaahXt474aWouDfvENcaINNtgLrPAqisgRckuyzfM/bU1a8Aj2OSLsSEh69giTi
+  0WxI115SHQG+8CyzpRQIBteomCInG1ymSyvEUxpytSW39KBVKViB84Ss5vcMvtv7
+  grVI0T63q4/t9yjlCPkbK1VTObseWNPA2/7twecdkCVN3VaWEml4xf2KiOwnKDfk
+  aZOXvndbbL+k3uaxs/Fpfsi0AD02HiceGjSOZFd9Wyk=
+  -----END CERTIFICATE-----
+date: 2014-06-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: With this gem, you can connect and perform any operation on Ribbon Flow.
+  It supports loading pool, card and transaction tokens. You can also easily credit
+  a card.
+email: engineering@ribbon.co
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/flow/config.rb
+- lib/flow/connection.rb
+- lib/flow/errors.rb
+- lib/flow/models/card.rb
+- lib/flow/models/model.rb
+- lib/flow/models/pool.rb
+- lib/flow/models/transaction.rb
+- lib/flow/models.rb
+- lib/flow/response.rb
+- lib/flow/version.rb
+- lib/flow.rb
+homepage: https://flow.ribbon.co
+licenses:
+- BSD
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Ruby SDK for the Ribbon Flow API.
+test_files: []