yodlee-icious 0.0.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 366b4521997b5e912f1cf8f45d7c3737b97ad6ed
+  data.tar.gz: f4bab7bf2bcd123a4ad18d5235f61a615f68d5ed
+SHA512:
+  metadata.gz: 43d586bcf5a8e3bdc918774121fa62709dfd90139c4cee170d4948ad431d717e4b7ad21b0c0d54693ea40a9b0bf23f0d07260c4525c8092d1926f38e1c7316b9
+  data.tar.gz: f03c4cbc0a69d67961d14503d2623b345851bf1b36954e8b0b940752660319adf0ccfb0182e5f775cc929cd103bdf0f6eed7c2eaa50a9c371e0b6bd92b821894

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,15 @@
+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'
+
+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,173 @@
+
+# Yodlee-icious
+[![Gem Version](https://badge.fury.io/rb/yodlicious.svg)](http://badge.fury.io/rb/yodlicious)  [![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)
+
+Yodleeicious 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 = {
+  base_url: "https://consolidatedsdk.yodlee.com/yodsoap/srest/my-cobranded-path/v1.0",
+  cobranded_username: "my-cobranded-user",
+  cobranded_password: "my-cobranded-password"
+}
+
+yodlee_api = Yodleeicious::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
+
+## 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/yodleeicious.rb

@@ -0,0 +1,27 @@
+require 'rubygems'
+require 'logger'
+require 'faraday'
+require 'socksify'
+require 'socksify/http'
+
+require File.dirname(__FILE__) + "/yodleeicious/version"
+require File.dirname(__FILE__) + "/yodleeicious/config"
+require File.dirname(__FILE__) + "/yodleeicious/parameter_translator"
+require File.dirname(__FILE__) + "/yodleeicious/response"
+require File.dirname(__FILE__) + "/yodleeicious/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

data/lib/yodleeicious/config.rb

@@ -0,0 +1,13 @@
+
+
+module Yodleeicious
+  class Config
+    class << self
+      attr_accessor :base_url, :cobranded_username, :cobranded_password, :proxy_url, :logger
+    end
+    
+    self.logger = Logger.new(STDOUT)
+    self.logger.level = Logger::WARN  
+
+  end
+end

data/lib/yodleeicious/parameter_translator.rb

@@ -0,0 +1,28 @@
+module Yodleeicious
+  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/yodleeicious/response.rb

@@ -0,0 +1,30 @@
+module Yodleeicious
+  class Response
+
+    def initialize body
+      @body = body
+    end
+
+    def success?
+      !fail?
+    end
+
+    def fail?
+      body.kind_of?(Hash) && (body['errorOccurred'] == 'true' || body.has_key?('Error'))
+    end
+
+    def body
+      @body
+    end
+
+    def error
+      if body.kind_of?(Hash)
+        if body.has_key?('Error')
+          body['Error'][0]['errorDetail']
+        elsif body['errorOccurred'] == 'true'
+          body['exceptionType']
+        end
+      end
+    end
+  end
+end

data/lib/yodleeicious/version.rb

@@ -0,0 +1,3 @@
+module Yodleeicious
+  VERSION = "0.0.4"
+end

data/lib/yodleeicious/yodlee_api.rb

@@ -0,0 +1,368 @@
+require 'json'
+
+
+module Yodleeicious
+  class YodleeApi
+    attr_reader :base_url, :cobranded_username, :cobranded_password, :proxy_url, :logger
+
+    def initialize config = {}
+      configure config
+    end
+
+    def configure config = {}
+      validate config
+      @base_url = config[:base_url] || Yodleeicious::Config.base_url
+      @cobranded_username = config[:cobranded_username] || Yodleeicious::Config.cobranded_username
+      @cobranded_password = config[:cobranded_password] || Yodleeicious::Config.cobranded_password
+      @proxy_url = config[:proxy_url] || Yodleeicious::Config.proxy_url
+      @logger = config[:logger] || Yodleeicious::Config.logger
+      
+      info_log "YodleeApi configured with base_url=#{base_url} cobranded_username=#{cobranded_username} proxy_url=#{proxy_url} logger=#{logger}"
+    end
+
+    def validate config
+      [:proxy_url, :base_url, :cobranded_username, :cobranded_password, :logger].each { |key|
+        if config.has_key?(key) && config[key].nil?
+          raise "Invalid config provided to YodleeApi. Values may not be nil or blank."
+        end
+      }
+    end
+
+    def proxy_opts
+      proxy_opts = {}
+
+      unless proxy_url == nil
+        proxy_opts[:uri] = URI.parse(proxy_url) 
+        proxy_opts[:socks] = use_socks?
+      end
+
+      proxy_opts
+    end
+
+    def use_socks?
+      return proxy_url != nil && proxy_url.start_with?('socks') 
+    end
+
+    def cobranded_login
+      params = {
+        cobrandLogin: cobranded_username,
+        cobrandPassword: cobranded_password
+      }
+
+      response = execute_api '/authenticate/coblogin', params
+
+      if response.success?
+        @cobranded_auth = response.body
+      else
+        @cobranded_auth = nil
+      end
+
+      response
+    end
+
+    def user_login login, pass
+      params = {
+        login: login,
+        password: pass
+      }
+
+      response = cobranded_session_execute_api '/authenticate/login', params
+
+      if response.success?
+        @user_auth = response.body
+      else
+        @user_auth = nil
+      end
+
+      response
+    end
+
+    def logout_user
+      user_session_execute_api '/jsonsdk/Login/logout'
+    end
+
+    def register_user username, password, emailAddress, options = {}
+      params = {
+        'userCredentials.loginName' => username,
+        'userCredentials.password' => password,
+        'userCredentials.objectInstanceType' => 'com.yodlee.ext.login.PasswordCredentials',
+        'userProfile.emailAddress' => emailAddress
+        #todo add in user preferences
+      }.merge(options)
+
+      response = cobranded_session_execute_api "/jsonsdk/UserRegistration/register3", params
+
+      if response.success?
+        @user_auth = response.body
+      else
+        @user_auth = nil
+      end
+
+      response
+    end
+
+    def login_or_register_user  username, password, email
+      info_log "attempting to login #{username}"
+      response = user_login(username, password)
+
+      #TODO look into what other errors could occur here
+      if response.fail? && response.error == "Invalid User Credentials"
+        info_log "invalid credentials for #{username} attempting to register"
+        response = register_user username, password, email
+      end
+
+      if response.success?
+        @user_auth = response.body
+      else
+        @user_auth = nil
+      end
+
+      response
+    end
+
+    def unregister_user
+      response = user_session_execute_api '/jsonsdk/UserRegistration/unregister'
+      if response.success?
+        @user_auth = nil
+      end
+
+      response
+    end
+
+    def site_search search_string
+      user_session_execute_api "/jsonsdk/SiteTraversal/searchSite", { siteSearchString: search_string }
+    end
+
+    def search_content_services search_string
+      user_session_execute_api "/jsonsdk/Search/searchContentServices", { keywords: search_string }
+    end
+
+    def add_site_account site_id, site_login_form
+      params = { 
+        siteId: site_id
+      }.merge(translator.site_login_form_to_add_site_account_params(site_login_form))
+
+      user_session_execute_api '/jsonsdk/SiteAccountManagement/addSiteAccount1', params
+    end
+
+
+    def add_site_account_and_wait site_id, site_login_form, refresh_interval = 0.5, max_trys = 5
+      add_site_account_response = add_site_account(site_id, site_login_form)
+
+      if add_site_account_response.success?
+        if normal_site_refresh_in_progress?(add_site_account_response.body['siteRefreshInfo'])
+          site_account_id = add_site_account_response.body['siteAccountId']
+          try = 1
+          begin
+            debug_log "try #{try} to get refresh_info for #{site_id}"
+            try += 1
+            sleep(refresh_interval)
+            refresh_info_response = get_site_refresh_info site_account_id
+            add_site_account_response.body['siteRefreshInfo'] = refresh_info_response.body unless refresh_info_response.fail?
+          end while should_retry_get_site_refresh_info? refresh_info_response, try, max_trys
+        end
+      end
+
+      add_site_account_response
+    end
+
+    def should_retry_get_site_refresh_info? response, try, max_trys
+      return response.success? && try < max_trys && (response.body['code'] == 801  || (response.body['code'] == 0 && 
+        response.body['siteRefreshStatus']['siteRefreshStatus'] != 'REFRESH_COMPLETED' &&
+        response.body['siteRefreshStatus']['siteRefreshStatus'] != 'REFRESH_TIMED_OUT' &&
+        response.body['siteRefreshStatus']['siteRefreshStatus'] != 'LOGIN_SUCCESS' ))
+    end
+
+    def normal_site_refresh_in_progress? site_refresh_info
+      return site_refresh_info['siteRefreshMode']['refreshMode'] == 'NORMAL' &&
+             ['REFRESH_TRIGGERED','PARTIAL_COMPLETE'].include?(site_refresh_info['siteRefreshStatus']['siteRefreshStatus'])
+    end
+
+    def get_mfa_response_for_site site_account_id
+      user_session_execute_api '/jsonsdk/Refresh/getMFAResponseForSite', { memSiteAccId: site_account_id }
+    end
+
+    def get_mfa_response_for_site_and_wait site_account_id, refresh_interval=0.5, max_trys=5
+      response = get_mfa_response_for_site site_account_id
+
+      try = 1
+      while should_retry_get_mfa_response? response, try, max_trys
+        debug_log "try #{try} to get mfa message for #{site_account_id}"
+        try += 1
+        sleep(refresh_interval)
+        response = get_mfa_response_for_site site_account_id
+      end
+
+      response
+    end
+
+    def should_retry_get_mfa_response? response, try, max_trys
+      return response.success? && response.body['errorCode'].nil? && response.body['isMessageAvailable'] != true && try < max_trys
+    end
+
+    def put_mfa_request_for_site site_account_id, mfa_type, field_info
+      params = {
+        'memSiteAccId' => site_account_id,
+        'userResponse.objectInstanceType' => "com.yodlee.core.mfarefresh.#{mfa_type}"
+      }
+
+      case mfa_type.to_sym
+      when :MFATokenResponse
+        params['userResponse.token']=field_info['fieldValue']
+      when :MFAImageResponse
+        params['userResponse.imageString']=field_info['fieldValue']
+      when :MFAQuesAnsResponse
+        questionsArray = field_info['questionAndAnswerValues']
+        i = 0
+        while i < questionsArray.length do
+          params["userResponse.quesAnsDetailArray[#{i}].answer"]=questionsArray[i]['fieldValue']
+          params["userResponse.quesAnsDetailArray[#{i}].answerFieldType"]=questionsArray[i]['answerFieldType']
+          params["userResponse.quesAnsDetailArray[#{i}].metaData"]=questionsArray[i]['metaData']
+          params["userResponse.quesAnsDetailArray[#{i}].question"]=questionsArray[i]['question']
+          params["userResponse.quesAnsDetailArray[#{i}].questionFieldType"]=questionsArray[i]['questionFieldType']
+          i += 1
+        end
+      end
+
+      user_session_execute_api '/jsonsdk/Refresh/putMFARequestForSite', params
+    end
+
+    def get_site_refresh_info site_account_id
+      user_session_execute_api '/jsonsdk/Refresh/getSiteRefreshInfo', { memSiteAccId: site_account_id }
+    end
+
+    def start_site_refresh site_account_id, refresh_priority = 1
+      params = {
+        'memSiteAccId' => site_account_id,
+        'refreshParameters.refreshPriority' => refresh_priority
+      }
+      user_session_execute_api '/jsonsdk/Refresh/startSiteRefresh', params
+    end
+
+    def get_content_service_info_by_routing_number routing_number, no_trim = true
+      params = {
+        routingNumber: routing_number,
+        notrim: no_trim
+      }
+
+      cobranded_session_execute_api '/jsonsdk/RoutingNumberService/getContentServiceInfoByRoutingNumber', params
+    end
+
+    def get_item_summaries
+      user_session_execute_api '/jsonsdk/DataService/getItemSummaries', { 'bridgetAppId' => '10003200' }
+    end
+
+    def get_item_summaries_for_site site_account_id
+      user_session_execute_api '/jsonsdk/DataService/getItemSummariesForSite', { memSiteAccId: site_account_id }
+    end
+
+    def get_all_site_accounts
+      user_session_execute_api '/jsonsdk/SiteAccountManagement/getAllSiteAccounts'
+    end
+
+    def get_site_login_form site_id
+      user_session_execute_api '/jsonsdk/SiteAccountManagement/getSiteLoginForm', { siteId: site_id }
+    end
+
+    def get_site_info site_id
+      params = {
+        'siteFilter.siteId' => site_id,
+        'siteFilter.reqSpecifier' => 16
+      }
+      cobranded_session_execute_api '/jsonsdk/SiteTraversal/getSiteInfo', params
+    end
+
+    def execute_user_search_request options = {}
+      params = {
+        'transactionSearchRequest.containerType' => 'All',
+        'transactionSearchRequest.lowerFetchLimit' => 1,
+        'transactionSearchRequest.higherFetchLimit' => 500,
+        'transactionSearchRequest.resultRange.startNumber' => 1,
+        'transactionSearchRequest.resultRange.endNumber' => 500,
+        'transactionSearchRequest.searchClients.clientId' => 1,
+        'transactionSearchRequest.searchClients.clientName' => 'DataSearchService',
+        'transactionSearchRequest.ignoreUserInput' => true,
+        #todo make it so that we can pass a simpler hash of arguments
+        # 'transactionSearchRequest.userInput' => nil,
+        # 'transactionSearchRequest.searchFilter.currencyCode' => nil,
+        # 'transactionSearchRequest.searchFilter.postDateRange.fromDate' => nil,
+        # 'transactionSearchRequest.searchFilter.postDateRange.toDate' => nil,
+        # 'transactionSearchRequest.searchFilter.itemAccountId.identifier' => nil,
+        'transactionSearchRequest.searchFilter.transactionSplitType' => 'ALL_TRANSACTION'
+      }.merge(options)
+
+      user_session_execute_api "/jsonsdk/TransactionSearchService/executeUserSearchRequest", params
+    end
+
+    def get_user_transactions search_identifier, start_number, end_number
+      params = {
+        'searchFetchRequest.searchIdentifier.identifier' => search_identifier,
+        'searchFetchRequest.searchResultRange.startNumber' => start_number,
+        'searchFetchRequest.searchResultRange.endNumber' => end_number
+      }
+      user_session_execute_api '/jsonsdk/TransactionSearchService/getUserTransactions', params
+    end
+
+    def cobranded_session_execute_api uri, params = {}
+      params = {
+        cobSessionToken: cobranded_session_token,
+      }.merge(params)
+
+      execute_api uri, params
+    end
+
+    def user_session_execute_api uri, params = {}
+      params = {
+        userSessionToken: user_session_token
+      }.merge(params)
+
+      cobranded_session_execute_api uri, params
+    end
+
+    def execute_api uri, params = {}
+      debug_log "calling #{uri} with #{params}"
+      ssl_opts = { verify: false }
+      connection = Faraday.new(url: base_url, ssl: ssl_opts, request: { proxy: proxy_opts })
+
+      response = connection.post("#{base_url}#{uri}", params)
+      debug_log "response=#{response.status} success?=#{response.success?} body=#{response.body} "
+
+      case response.status
+      when 200
+        Response.new(JSON.parse(response.body))
+      else
+      end
+    end
+
+    def translator
+      @translator ||= ParameterTranslator.new
+    end
+
+    def cobranded_auth
+      @cobranded_auth
+    end
+
+    def user_auth
+      @user_auth
+    end
+
+    def cobranded_session_token
+      return nil if cobranded_auth.nil?
+      cobranded_auth.fetch('cobrandConversationCredentials',{}).fetch('sessionToken','dude')
+    end
+
+    def user_session_token
+      return nil if user_auth.nil?
+      user_auth.fetch('userContext',{}).fetch('conversationCredentials',{}).fetch('sessionToken',nil)
+    end
+
+    def debug_log msg
+      logger.debug msg
+    end
+
+    def info_log msg
+      logger.info msg
+    end
+
+  end
+end