vestorly_api 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 19465edda2fedfc554025d76141293240c906024
+  data.tar.gz: ef795cee4d5b01e3f0ee1f4df32237fd35778c4b
+SHA512:
+  metadata.gz: 74ffe20691f94828cc7c0e8838172b55a279e0ac8931bb3c23a20a41dedf801f52c29e0cf4d4bec4f3f4fccfeebe15ec7235a1907436535d9614721bdd2d6349
+  data.tar.gz: 396a7063aac7bb2ce13ca7dec354d25a81268ebce11880846c71cddffd54e42c632db76239236a7cb5e173fab3b7b0304e497a0170bc3b3c9dadff9642b75c1e

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format documentation

data/Gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in vestorly_api.gemspec
+gemspec
+

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 David Rodas
+
+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,151 @@
+# VestorlyApi
+
+The Vestorly API provides the ability for external developers to synchronize their client data with Vestorly.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'vestorly_api'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install vestorly_api
+
+## Running the tests
+
+```bash
+rspec
+```
+
+## Basic Setup
+
+To setup the client, you'll need the following configuration.
+
+Rails example
+
+```ruby
+VestorlyApi.configure do |config|
+  config.api_uri = ENV['VESTORLY_API_URI']
+end
+```
+
+### SignIn to Vestorly API
+
+Sign in will return the authentication token on success, and if the sign_in is invalid, it will raise `VestorlyApi::Exceptions::InvalidSignInCredentials`
+
+**Example**: Authentication to the API
+
+```ruby
+sign_in_api = VestorlyApi::SignIn.new('my@user.com', 'password')
+
+begin
+  authentication_token = sign_in_api.sign_in # vestorly-auth
+rescue VestorlyApi::Exceptions::InvalidSignInCredentials
+  # Do rescue stuff...
+end
+```
+
+`VestorlyApi::SignIn` also provides the following public methods usable after the sign_in was successful:
+
+```ruby
+sign_in_api.authentication_token # vestorly-auth
+sign_in_api.advisor_id # advisor id
+```
+
+### Using the advisor API object
+
+Once logged in with a valid sign_in object, it can be passed to the `VestorlyApi::Advisor` to request on the advisor API part:
+
+**Example**: Obtain the list of prospective clients for the logged in advisor
+
+```ruby
+sign_in_api = VestorlyApi::SignIn.new('my@user.com', 'password')
+sign_in_api.sign_in
+
+advisor_api = VestorlyApi::Advisor.new(sign_in_api)
+advisor_user_entries = advisor_api.advisor_user_entries
+
+# with query params
+query_params_hash = { 'filter_by' => 'prospects' }
+advisor_user_entries = advisor_api.advisor_user_entries( query_params_hash )
+```
+
+**Example**: Return a list of active advisor accounts
+
+
+```ruby
+sign_in_api = VestorlyApi::SignIn.new('my@user.com', 'password')
+sign_in_api.sign_in
+
+advisor_api = VestorlyApi::Advisor.new(sign_in_api)
+advisor_posts = advisor_api.advisor_posts
+
+# with query params
+query_params_hash = { 'filter_by' => 'prospects' }
+advisor_posts = advisor_api.advisor_posts(query_params_hash)
+```
+
+**Example**: Creating a new reader for the advisor
+
+```ruby
+require 'vestorly_api'
+
+sign_in_api = VestorlyApi::SignIn.new('my@user.com', 'password')
+sign_in_api.sign_in
+
+advisor_api = VestorlyApi::AdvisorBase.new(sign_in_api)
+
+new_member_params = {
+  email: "lovecraft@gmail.com",
+  first_name: "Love",
+  group_id: "541c9e06c3b5a0bdda000001",
+  last_name: "Craft"
+}
+
+new_member = advisor_api.create_member( new_member_params )
+
+```
+
+**NB**: The examples above asume the sign_in was successful
+
+
+### Sign out of Vestorly API
+
+To sign out of the Vestorly API we can use the `VestorlyApi::SigOut` object
+
+**Example**: The sign out can be call in the 2 following forms
+
+```ruby
+# Creating an object and calling sign_out method
+response = VestorlyApi::SignOut.new(authentication_token).sign_out
+
+# Calling sig_out method on the class
+response = VestorlyApi::SignOut.sign_out(authentication_token)
+
+# response is a hash containing code and message keys
+p response # { code: 202, message: "Successfully logged out." }
+
+# with invalid authentication token
+p response # { code: 404, message: "Not signed in. }
+```
+
+## Dependencies
+
+### Ruby
+
+```bash
+ruby 2.1.1p76
+```
+
+## Contributing
+
+1. Fork it ( http://github.com/<my-github-username>/vestorly_api/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 new Pull Request

data/Rakefile

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

data/lib/vestorly_api.rb

@@ -0,0 +1,30 @@
+require 'httparty'
+
+require 'vestorly_api/version'
+require 'vestorly_api/exceptions'
+require 'vestorly_api/default_endpoint'
+
+require 'vestorly_api/response_utils'
+
+require 'vestorly_api/sign_in'
+require 'vestorly_api/sign_out'
+
+require 'vestorly_api/advisor_base'
+require 'vestorly_api/member'
+
+module VestorlyApi
+  class << self
+    attr_accessor :config
+  end
+
+  def self.configure
+    self.config ||= Configuration.new
+    yield config
+    raise VestorlyApi::Exceptions::InvalidURIError if (config.api_uri =~ URI::regexp).nil?
+    config.api_uri << '/' unless config.api_uri[-1, 1] == '/'
+  end
+
+  class Configuration
+    attr_accessor :api_uri
+  end
+end

data/lib/vestorly_api/advisor_base.rb

@@ -0,0 +1,74 @@
+module VestorlyApi
+  class AdvisorBase
+
+    include HTTParty
+    extend DefaultEndpoint
+    extend ResponseUtils
+
+    def initialize(authenticated_sign_in)
+      @authenticated_sign_in = authenticated_sign_in
+      @query_params
+    end
+
+    def self.advisor_api_endpoint
+      "#{AdvisorBase.default_api_endpoint}/advisors"
+    end
+
+    def action_api_endpoint(request_action)
+      "#{AdvisorBase.advisor_api_endpoint}/#{@authenticated_sign_in.advisor_id}/#{request_action}"
+    end
+
+    def members(query_params={})
+      members_response = get_request('advisor_user_entries.json', query_params)
+      return members_response['members'] if members_response.key?('members')
+      return members_response
+    end
+
+    def advisor_posts(query_params={})
+      get_request('posts.json', query_params)
+    end
+
+    def create_member(post_params={})
+      post_request('members.json', { member: post_params })
+      return new_member['member'] if new_member.response.code == '201'
+      return new_member
+    end
+
+    protected
+
+    # TODO: refactor this to a query object
+    def post_request(request_action, query_params={})
+      AdvisorBase.post( action_api_endpoint(request_action), :query => request_query_params(query_params))
+    end
+
+    def get_request(request_action, query_params={})
+      AdvisorBase.get( action_api_endpoint(request_action), :query => request_query_params(query_params))
+    end
+
+    def put_request(request_action, query_params={})
+      AdvisorBase.put( action_api_endpoint(request_action), :query => request_query_params(query_params))
+    end
+
+    def delete_request(request_action, query_params={})
+      AdvisorBase.put( action_api_endpoint(request_action), :query => request_query_params(query_params))
+    end
+
+    def request_query_params(query_params={})
+      default_query_params.merge(query_params)
+    end
+
+    def default_query_params
+      {
+        "vestorly-auth" => @authenticated_sign_in.authentication_token
+      }
+    end
+
+    def query_params_to_string(query_params_hash)
+      query_params_string = ""
+      query_params_hash.each do |key, value|
+        query_params_string += "&#{key}=#{value}"
+      end
+      query_params_string
+    end
+  end
+end

data/lib/vestorly_api/default_endpoint.rb

@@ -0,0 +1,18 @@
+module VestorlyApi
+  module DefaultEndpoint
+
+    extend self
+
+    def base_api_uri
+      VestorlyApi.config.api_uri
+    end
+
+    def default_api_endpoint(version=self.api_version)
+      "#{base_api_uri}api/v#{version}"
+    end
+
+    def api_version
+      1
+    end
+  end
+end

data/lib/vestorly_api/exceptions.rb

@@ -0,0 +1,10 @@
+module VestorlyApi
+  module Exceptions
+
+    class Error < StandardError; end
+    class AuthenticationError < Error; end
+    class InvalidSignInCredentials < Error; end
+    class InvalidURIError < Error; end
+
+  end
+end

data/lib/vestorly_api/member.rb

@@ -0,0 +1,20 @@
+module VestorlyApi
+  class Member < AdvisorBase
+
+    DEFAULT_ACTION = 'members.json'.freeze
+    FETCH_DEFAULT_ACTION = 'advisor_user_entries.json'.freeze
+
+    def fetch(qury_params={})
+      response = get_request(FETCH_DEFAULT_ACTION, qury_params)
+      if Member.ok_response?(response)
+        response['members']
+      else
+        raise VestorlyApi::Exceptions::Error
+      end
+    end
+
+    def create(member_params={})
+
+    end
+  end
+end

data/lib/vestorly_api/response_utils.rb

@@ -0,0 +1,19 @@
+module VestorlyApi
+  module ResponseUtils
+
+    extend self
+
+    def ok_response?(response)
+      response_status_code(response).between?(200, 201)
+    end
+
+    def response_status_code(response)
+      response.code
+    end
+
+    def response_status_message(response)
+      response.message
+    end
+
+  end
+end

data/lib/vestorly_api/sign_in.rb

@@ -0,0 +1,56 @@
+module VestorlyApi
+  class SignIn
+
+    include HTTParty
+    extend DefaultEndpoint
+
+    def initialize(username, password)
+      @username = username
+      @password = password
+      @authentication_token = nil
+      @sign_in_response = nil
+    end
+
+    def sign_in
+      @sign_in_response = SignIn.post( SignIn.sign_in_api_endpoint, query: default_query_params )
+      if ok_response?
+        authentication_token
+      else
+        raise VestorlyApi::Exceptions::InvalidSignInCredentials
+      end
+    end
+
+    def authentication_token
+      @sign_in_response["vestorly-auth"]
+    end
+
+    def self.sign_in_api_endpoint
+      "#{SignIn.default_api_endpoint}/session_management/sign_in?version=#{SignIn.api_version}"
+    end
+
+    def advisor_id
+      @sign_in_response["advisor_id"]
+    end
+
+    private
+
+    def default_query_params
+      {
+        :username => @username,
+        :password => @password
+      }
+    end
+
+    def ok_response?
+      response_status_code.between?(200, 201)
+    end
+
+    def response_status_code
+      @sign_in_response.code
+    end
+
+    def response_status_message
+      @sign_in_response.message
+    end
+  end
+end