yodlee_wrap 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 333e83243a0aa385ef387bdcdea95b1b6e8d3d93
+  data.tar.gz: 46f43b8085cf36b894ad595788b3b15367d325de
+SHA512:
+  metadata.gz: 378bae78d518fa9311b3ca23f2aee56e8f0ad5aa32dcc22d5c10e58ac191bb686ec4bf749730f4f6ca7988347bb1a10baf1848d0faacc9f04931508b953dfcd7
+  data.tar.gz: 87d2975006769dd6f8070a994ea3cdbeb6c5a31865380f50869e1667da86d11c14a569d6a55d3406104682a3ef6c10c5326f0e21885ea09cd5c499a354c3947b

data/.gitignore

@@ -0,0 +1,15 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+.env

data/.rspec

@@ -0,0 +1,4 @@
+--color
+--format doc
+--tag ~skip
+--require spec_helper

data/Gemfile

@@ -0,0 +1,16 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in yodleeicious.gemspec
+gemspec
+
+gem 'faraday', '0.9.1'
+gem 'faraday_middleware', '~>0.9.1'
+gem 'socksify', '~>1.6.0'
+gem 'dotenv'
+gem 'byebug'
+
+group :development, :test do
+  gem "codeclimate-test-reporter"
+  gem "guard-rspec"
+  gem 'rspec-its'
+end

data/Guardfile

@@ -0,0 +1,16 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+# Note: The cmd option is now required due to the increasing number of ways
+#       rspec may be run, below are examples of the most common uses.
+#  * bundler: 'bundle exec rspec'
+#  * bundler binstubs: 'bin/rspec'
+#  * spring: 'bin/rsspec' (This will use spring if running and you have
+#                          installed the spring binstubs per the docs)
+#  * zeus: 'zeus rspec' (requires the server to be started separetly)
+#  * 'just' rspec: 'rspec'
+guard :rspec, cmd: "bundle exec rspec" do
+  watch(%r{^spec/(.+)_spec\.rb$})
+  watch('spec/spec_helper.rb')    { "spec" }
+  watch(%r{^lib/(.+)\.rb$})       { |m| "spec/unit/#{m[1]}_spec.rb" }
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Drew Nichols
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,176 @@
+
+# Yodlee-icious
+[![Gem Version](https://badge.fury.io/rb/yodlee-icious.svg)](http://badge.fury.io/rb/yodlee-icious)  [![Code Climate](https://codeclimate.com/repos/556dcf7fe30ba00903005872/badges/9398ac76dbcae2084eeb/gpa.svg)](https://codeclimate.com/repos/556dcf7fe30ba00903005872/feed) [![Test Coverage](https://codeclimate.com/repos/556dcf7fe30ba00903005872/badges/9398ac76dbcae2084eeb/coverage.svg)](https://codeclimate.com/repos/556dcf7fe30ba00903005872/coverage)
+[ ![Codeship Status for liftforward/yodlee-icious](https://codeship.com/projects/71603f00-9393-0132-dcd0-1a9a253548c0/status?branch=master)](https://codeship.com/projects/62288)
+
+Yodlee-icious (formally Yodlicious) is a ruby gem wrapping the Yodlee REST(ish) API. We had to build this for our integration with Yodlee which was somewhat more painful than it should have been so we figured we share to be a good neighbor.
+
+![image of yodleeicious](https://github.com/liftforward/yodlee-icious/blob/master/yodlicious.png)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'yodlee-icious'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install yodlee-icious
+
+## Usage
+
+### Configuration
+
+We needed to use the Yodlee API both within a rails app and outside with multiple Yodlee connections concurrently. As such we provided both the option for a global default configuration and a instance specific configuration. For instance specific:
+
+```ruby
+require "yodleeicious"
+
+config = {
+  cobranded_username: your_username,
+  cobranded_password: your_password
+}
+
+yodlee_api = YodleeWrap::YodleeApi.new(config)
+
+```
+When in a Rails app it can be more convenient to use a global default configuration. To use global defaults:
+
+```ruby
+#/<myproject>/config/initializers/yodleeicious.rb
+require 'yodleeicious'
+
+#setting default configurations for Yodleeicious
+Yodleeicious::Config.base_url = ENV['YODLEE_BASE_URL']
+Yodleeicious::Config.cobranded_username = ENV['YODLEE_COBRANDED_USERNAME']
+Yodleeicious::Config.cobranded_password = ENV['YODLEE_COBRANDED_PASSWORD']
+
+#setting yodleeicious logger to use the Rails logger
+Yodleeicious::Config.logger = Rails.logger
+```
+and wherever you want to use the api simply create a new one and it will pickup the global defaults.
+
+```ruby
+yodlee_api = Yodleeicious::YodleeApi.new
+```
+If for any reason you need to, you can pass a hash into the constructor and it will use any provided hash values over the defaults. Note this is done on each value not the entire hash.
+
+You can also update an existing instances of the YodleeApi's configuration with the configure method. For example:
+
+```ruby
+
+yodlee_api = Yodleeicious::YodleeApi.new { base_url: 'http://yodlee.com/blablabla' }
+
+yodlee_api.configure { base_url: 'https://secure.yodlee.com/blablabla }
+
+puts yodlee_api.base_url
+```
+will output
+
+```
+https://secure.yodlee.com/blablabla
+```
+
+### Configuring the proxy
+
+If you're Yodlee account is like ours Yodlee will whitelist certain IPs for access and you'll need to proxy all of your API requests through that IP. You can set the proxy with the proxy_url key. Currently the proxy supports, http, https, and socks proxies. Simply set the proxy_url property in the config hash passed to YodleeApi and it should begin using the proxy. For example:
+
+```
+config = {
+  base_url: "https://consolidatedsdk.yodlee.com/yodsoap/srest/my-cobranded-path/v1.0",
+  cobranded_username: "my-cobranded-user",
+  cobranded_password: "my-cobranded-password",
+  proxy_url: "https://my-proxy-server-on-the-whitelist:my=proxy-port/"
+}
+
+yodlee_api = Yodleeicious::YodleeApi.new(config)
+```
+
+## Working with the API
+
+The Yodlee Api responses are somewhat varied (especially the errors) and as such we build Yodleeicious as a pretty thin layer around their request/response model. We didn't attempt to map all their JSON responses into models or anything fancy like that. Instead we simply created a method for each API endpoint which takes the required parameters and return a response object. That said, Response object does provide some conveniences to make up for the inconsistent delivery of errors from Yodlee's APIs.
+
+### Starting your cobranded session
+
+Once you've configured an instance of the YodleeAPI the first thing you must do is start a Yodlee cobranded session. This is also a good rails console test to see if everything is configured correctly:
+
+```ruby
+pry(main)> yodlee_api = Yodleeicious::YodleeApi.new
+pry(main)> response = yodlee_api.cobranded_login
+pry(main)> response.success?
+=> true
+```
+As you probably suspect the call to cobranded_login wraps the ```/authenticate/coblogin``` endpoint call. If this is a success the YodleeApi instance will cache the cobranded session id yodlee returned and use it on all subsequent api calls. You can also access this value if desired with YodleeApi#cobranded_session_token.
+
+```
+pry(main)> yodlee_api.cobranded_session_token
+=> "12162013_1:a0b1ac3e32a2e656f8f5bd21de23ae1721ffd9dab8bee9f29811f5959bbf102f16c98354eba252bb030dc96e267bd2489a40562f18e09ee8ba9038d19280cc43"
+```
+At this point something has probably gone wrong for you and you want to see the response json from ```/authenticate/coblogin```. To do this simply use ```response#body```.
+
+```
+pry(main)> response.body
+=> {"Error"=>[{"errorDetail"=>"Invalid Cobrand Credentials"}]}
+```
+
+### Starting a user session
+
+Once the cobranded session is active a number of API endpoints will work however most of the interesting ones require you to register or login under a user account. It is within these accounts that you can add the user's bank accounts and whatnot to aggregate their financial data. There are 3 methods offered to allow you to #register_user, #login_user, or do either #login_or_register_user. After executing any of these the user session will be started and the user's session token will be cached in the YodleeApi instance and used on subsequent calls to api endpoints. As with all api calls if the call was not successful you'll need to look at the body of the response to determine what went wrong.
+
+### Registering a new user
+
+```
+pry(main)> response = yodlee_api.register_user 'my-username', 'my-password123', 'my-email@my-domain.com'
+pry(main)> yodlee_api.user_session_token
+=> "12162013_1:69761d51a4010e6382ccb49b854513dbccad0f835a873d37884b68826acefaa5b8d41b634f4cc83d97d86e7df861f70860a4e4d8a3f08d5b5440eae504af5f19"
+```
+
+### Login existing user
+
+```
+pry(main)> response = yodlee_api.user_login 'my-username', 'my-password123'
+pry(main)> yodlee_api.user_session_token
+=> "12162013_1:69761d51a4010e6382ccb49b854513dbccad0f835a873d37884b68826acefaa5b8d41b634f4cc83d97d86e7df861f70860a4e4d8a3f08d5b5440eae504af5f19"
+```
+
+### Convenience for doing both
+
+In case you have a situation where you don't know if the user is already registered there is #login_or_register_user
+
+```
+pry(main)> response = yodlee_api.login_or_register_user 'my-username', 'my-password123', 'my-email@my-domain.com'
+pry(main)> yodlee_api.user_session_token
+=> "12162013_1:69761d51a4010e6382ccb49b854513dbccad0f835a873d37884b68826acefaa5b8d41b634f4cc83d97d86e7df861f70860a4e4d8a3f08d5b5440eae504af5f19"
+```
+### other API methods
+
+TODO
+
+## Why the rename from Yodlicious?
+
+Rubygems.org's search apparently only indexes the gem name not the description or summary. This meant that if you searched for Yodlee in there Yodlicous didn't show up. Now it does.
+
+## Contributing
+
+1. Fork it ( https://github.com/liftforward/yodlee-icious/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request
+
+### Running the integration suite
+
+To run the Yodlee-icious integration tests you'll need an approved yodlee account. This is more than the one offered here [https://devnow.yodlee.com/user/register]. (Some of the integration suite will work against the devnow APIs but not all. On my todo list is to separate them out to make testing easier.) The integration suite expects these values to be set in the following environment variables:
+
+```
+YODLEE_BASE_URL="https://consolidatedsdk.yodlee.com/yodsoap/srest/my-cobranded-path/v1.0"
+YODLEE_COBRANDED_USERNAME="my-cobranded-user"
+YODLEE_COBRANDED_PASSWORD="my-cobranded-password"
+YODLEEICIOUS_PROXY_URL="https://my-proxy-server-on-the-whitelist:my=proxy-port/"
+```

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/lib/yodlee_wrap/config.rb

@@ -0,0 +1,14 @@
+
+
+module YodleeWrap
+  class Config
+    class << self
+      attr_accessor :cobranded_username, :cobrand_name, :cobranded_password,
+                    :proxy_url, :logger, :webhook_endpoint
+    end
+
+    self.logger = Logger.new(STDOUT)
+    self.logger.level = Logger::WARN
+
+  end
+end

data/lib/yodlee_wrap/parameter_translator.rb

@@ -0,0 +1,27 @@
+module YodleeWrap
+  class ParameterTranslator
+    def site_login_form_to_add_site_account_params site_login_form
+
+      params = { "credentialFields.enclosedType" => "com.yodlee.common.FieldInfoSingle" }
+
+      i = 0
+      site_login_form['componentList'].each { |field|
+        # puts "field=#{field}"
+        params["credentialFields[#{i}].displayName"] = field['displayName']
+        params["credentialFields[#{i}].fieldType.typeName"] = field['fieldType']['typeName']
+        params["credentialFields[#{i}].helpText"] = field['helpText']
+        params["credentialFields[#{i}].maxlength"] = field['maxlength']
+        params["credentialFields[#{i}].name"] = field['name']
+        params["credentialFields[#{i}].size"] = field['size']
+        params["credentialFields[#{i}].value"] = field['value']
+        params["credentialFields[#{i}].valueIdentifier"] = field['valueIdentifier']
+        params["credentialFields[#{i}].valueMask"] = field['valueMask']
+        params["credentialFields[#{i}].isEditable"] = field['isEditable']
+        params["credentialFields[#{i}].value"] = field['fieldValue']
+
+        i += 1
+      }
+      params
+    end
+  end
+end

data/lib/yodlee_wrap/response.rb

@@ -0,0 +1,20 @@
+module YodleeWrap
+  class Response
+    attr_accessor :body, :status, :error_code, :error_message
+
+    def initialize(body, status)
+      @body = body
+      @status = status
+      @error_code = body.fetch('errorCode') if fail?
+      @error_message = body.fetch('errorMessage') if fail?
+    end
+
+    def success?
+      !fail?
+    end
+
+    def fail?
+      body.is_a?(Hash) && !(body.fetch('errorCode', nil)).nil?
+    end
+  end
+end

data/lib/yodlee_wrap/version.rb

@@ -0,0 +1,3 @@
+module YodleeWrap
+  VERSION = "0.0.0"
+end

data/lib/yodlee_wrap/yodlee_api.rb

@@ -0,0 +1,183 @@
+require 'json'
+
+module YodleeWrap
+  class YodleeApi
+    attr_reader :base_url, :cobranded_username, :cobranded_password, :proxy_url,
+                :logger, :cobranded_auth, :user_auth, :cobrand_name, :webhook_endpoint
+
+    def initialize(config = {})
+      configure(config)
+    end
+
+    def configure(config = {})
+      validate(config)
+      @cobrand_name = config[:cobrand_name] || YodleeWrap::Config.cobrand_name || 'restserver'
+      @cobranded_username = config[:cobranded_username] || YodleeWrap::Config.cobranded_username
+      @cobranded_password = config[:cobranded_password] || YodleeWrap::Config.cobranded_password
+      @webhook_endpoint = config[:webhook_endpoint] || YodleeWrap::Config.webhook_endpoint
+      @logger = config[:logger] || YodleeWrap::Config.logger
+
+      info_log "YodleeApi configured with base_url=#{base_url} cobranded_username=#{cobranded_username} logger=#{logger}"
+    end
+
+    def validate(config)
+      [:cobranded_username, :cobranded_password, :logger].each do |key|
+        if config.key?(key) && config[key].nil?
+          fail 'Invalid config provided to YodleeApi. Values may not be nil/blank.'
+        end
+      end
+    end
+
+    def cobranded_login
+      params = {
+        cobrand: {
+          cobrandLogin: cobranded_username,
+          cobrandPassword: cobranded_password,
+          locale: "en_US"
+        }
+      }
+      response = execute_api('/v1/cobrand/login', params)
+
+      @cobranded_auth = response.success? ? response.body : nil
+
+      response
+    end
+
+    def user_params(username, password)
+      {
+        user: {
+          loginName: username,
+          password: password,
+          locale: 'en_US'
+        }
+      }
+    end
+
+    def user_login(username:, password:)
+      params = user_params(username, password)
+      response = cobranded_session_execute_api('/v1/user/login', params)
+      @user_auth = response.success? ? response.body : nil
+      response
+    end
+
+    def register_user(username:, password:, options: {}, subscribe: true)
+      params = user_params(username, password).merge(options)
+      response = cobranded_session_execute_api('/v1/user/register', params)
+      @user_auth = response.success? ? response.body : nil
+      subscribe_user_to_refresh if response.success? && subscribe
+      response
+    end
+
+    # subscribe user to webhook refresh notifications
+    def subscribe_user_to_refresh
+      params = {
+        event: {
+          callbackUrl: webhookEndpoint
+        }
+      }
+      user_session_execute_api('v1/cobrand/config/notifications/events/REFRESH', params)
+    end
+
+    def unregister_user
+      response = user_session_execute_api('v1/user/unregister')
+      @user_auth = nil if response.success?
+    end
+
+    def logout_user
+      user_session_execute_api('/v1/user/logout')
+    end
+
+    def login_or_register_user(username:, password:, subscribe: true)
+      info_log "Attempting to log in #{username}"
+      response = user_login(username: username, password: password)
+
+      # TODO: look into what other errors could occur here
+      if response.fail? && response.error_code == 'Y002'
+        info_log "Invalid credentials for #{username}. Attempting to register"
+        response = register_user(username: username, password: password, subscribe: subscribe)
+      else
+        info_log response.error_message
+      end
+
+      @user_auth = response.success? ? response.body : nil
+
+      response
+    end
+
+    def get_provider_details(provider_id)
+      user_session_execute_api("/v1/providers/#{provider_id}")
+    end
+
+    def add_provider_account(provider_id, provider_params)
+      user_session_execute_api("v1/providers/#{provider_id}", provider_params)
+    end
+
+    def delete_provider_account(provider_account_id)
+      user_session_execute_api("v1/providers/providerAccounts/#{provider_account_id}")
+    end
+
+    # After an account has been added, use the returned provider_account_id
+    # to get updates about the provider account.
+    def get_provider_account_status(provider_account_id)
+      user_session_execute_api("v1/providers/#{provider_account_id}")
+    end
+
+    def update_provider_account(provider_account_id, provider_params)
+      user_session_execute_api("v1/providers/providerAccounts?providerAccountIds=#{provider_account_id}", provider_params)
+    end
+
+    def cobranded_session_execute_api(url, params = {})
+
+      execute_api(url, params, cobranded_auth_header)
+    end
+
+    def user_session_execute_api(url, params = {})
+
+      execute_api(url, params, user_auth_header)
+    end
+
+    def cobranded_auth_header
+      "cobSession=#{cobranded_session_token}"
+    end
+
+    def user_auth_header
+      cobranded_auth_header + "userSession=#{user_session_token}"
+    end
+
+    def execute_api(url, params, auth_header = "")
+      debug_log "calling #{url} with #{params}"
+      ssl_opts = { verify: false }
+      connection = Faraday.new(url: base_url, ssl: ssl_opts, request: { proxy: [] })
+      response = connection.post do |request|
+        request.url "#{base_url}#{url}"
+        request.headers['Content-Type'] = 'application/json'
+        request.headers['Authorization'] = auth_header
+        request.body = params.to_json
+      end
+      debug_log "response=#{response.status} success?=#{response.success?} body=#{response.body}"
+      Response.new(JSON.parse(response.body), response.status)
+    end
+
+    def cobranded_session_token
+      return nil if cobranded_auth.nil?
+      cobranded_auth.fetch('session', {}).fetch('cobSession', nil)
+    end
+
+    def user_session_token
+      return nil if user_auth.nil?
+      user_auth.fetch('session', {}).fetch('userSession', nil)
+    end
+
+    def debug_log(msg)
+      logger.debug(msg)
+    end
+
+    def info_log(msg)
+      logger.info(msg)
+    end
+
+    def base_url
+      "https://developer.api.yodlee.com/ysl/#{cobrand_name}"
+    end
+  end
+end

data/lib/yodlee_wrap.rb

@@ -0,0 +1,27 @@
+require 'rubygems'
+require 'logger'
+require 'faraday'
+require 'socksify'
+require 'socksify/http'
+
+require File.dirname(__FILE__) + "/yodlee_wrap/version"
+require File.dirname(__FILE__) + "/yodlee_wrap/config"
+require File.dirname(__FILE__) + "/yodlee_wrap/parameter_translator"
+require File.dirname(__FILE__) + "/yodlee_wrap/response"
+require File.dirname(__FILE__) + "/yodlee_wrap/yodlee_api"
+
+class Faraday::Adapter::NetHttp
+  def net_http_connection(env)
+    if !(proxy = env[:request][:proxy]).empty?
+      if proxy[:socks]
+        # TCPSocket.socks_username = proxy[:user] if proxy[:user]
+        # TCPSocket.socks_password = proxy[:password] if proxy[:password]
+        Net::HTTP::SOCKSProxy(proxy[:uri].host, proxy[:uri].port)
+      else
+        Net::HTTP::Proxy(proxy[:uri].host, proxy[:uri].port, proxy[:uri].user, proxy[:uri].password)
+      end
+    else
+      Net::HTTP
+    end.new(env[:url].host, env[:url].port)
+  end
+end