questrade_api 0.0.1 → 0.0.2

data/lib/questrade_api/rest/activity.rb

@@ -0,0 +1,58 @@
+require 'questrade_api/rest/base'
+
+module QuestradeApi
+  module REST
+    # @author Bruno Meira <goesmeira@gmail.com>
+    class Activity < QuestradeApi::REST::Base
+      attr_accessor :account_id
+
+      def initialize(params)
+        @account_id = params[:account_id]
+
+        @raw_body = params[:data]
+        build_data(params[:data]) if @raw_body
+      end
+
+      #
+      # Fetch account activities
+      #
+      # @param authorization [QuestradeApi::Authorization] with the authorized #access_token and #url.
+      # @param account_number [String] with the account the activities will be fetched
+      # @param params [Hash] with the range of dates the activities will be fetched
+      # @option params [String] :startTime The start time. ex: '2011-02-16T00:00:00.000000-05:00'
+      # @option params [String] :endTime The end time. ex: '2011-02-16T00:00:00.000000-05:00'
+      def self.all(authorization, account_number, params)
+        response = super(access_token: authorization.access_token,
+                         endpoint: endpoint(account_number),
+                         url: authorization.url,
+                         params: params)
+
+        result = OpenStruct.new(activities: [])
+
+        if response.status == 200
+          result.activities = parse_activities(account_number, response.body)
+        end
+
+        result
+      end
+
+      def self.endpoint(account_id)
+        "#{BASE_ENDPOINT}/accounts/#{account_id}/activities"
+      end
+
+      def self.parse_activities(account_number, body)
+        raw = JSON.parse(body)
+
+        activities = []
+
+        raw['activities'].each do |activity|
+          activities << new(account_id: account_number, data: activity)
+        end
+
+        activities
+      end
+
+      private_class_method :parse_activities
+    end
+  end
+end

data/lib/questrade_api/rest/balance.rb

@@ -0,0 +1,81 @@
+require 'questrade_api/rest/base'
+
+module QuestradeApi
+  module REST
+    # @author Bruno Meira <goesmeira@gmail.com>
+    class Balance < QuestradeApi::REST::Base
+      attr_accessor :account_id
+
+      def initialize(params)
+        @account_id = params[:account_id]
+
+        @raw_body = params[:data]
+        build_data(params[:data]) if @raw_body
+      end
+
+      #
+      # Fetch account balances
+      #
+      # @param authorization [QuestradeApi::Authorization] with the authorized #access_token and #url.
+      # @param account_number [String] with the account the activities will be fetched
+      # @return [OpenStruct(per_currency_balances, combined_balances, sod_per_currency_balances, sod_combined_balances)] If call succeeds. Each method returns an array of QuestradeApi::REST::Balance
+      # @return [Faraday::Response] if call fails.
+      def self.all(authorization, account_number)
+        response = super(access_token: authorization.access_token,
+                         endpoint: endpoint(account_number),
+                         url: authorization.url)
+
+        result = OpenStruct.new(per_currency_balances: [],
+                                combined_balances: [],
+                                sod_per_currency_balances: [],
+                                sod_combined_balances: [])
+
+        if response.status == 200
+          parse_balances(account_number, response.body).each do |key, value|
+            result.send("#{key}=", value)
+          end
+        end
+
+        result
+      end
+
+      def self.endpoint(account_id)
+        "#{BASE_ENDPOINT}/accounts/#{account_id}/balances"
+      end
+
+      def self.parse_balances(account_number, body)
+        raw = JSON.parse(body)
+        balances = {
+          per_currency_balances: [],
+          combined_balances: [],
+          sod_per_currency_balances: [],
+          sod_combined_balances: []
+        }
+
+        raw['perCurrencyBalances'].each do |balance|
+          balances[:per_currency_balances] << new(account_id: account_number,
+                                                  data: balance)
+        end
+
+        raw['combinedBalances'].each do |balance|
+          balances[:combined_balances] << new(account_id: account_number,
+                                              data: balance)
+        end
+
+        raw['sodPerCurrencyBalances'].each do |balance|
+          balances[:sod_per_currency_balances] << new(account_id: account_number,
+                                                      data: balance)
+        end
+
+        raw['sodCombinedBalances'].each do |balance|
+          balances[:sod_combined_balances] << new(account_id: account_number,
+                                                  data: balance)
+        end
+
+        balances
+      end
+
+      private_class_method :parse_balances
+    end
+  end
+end

data/lib/questrade_api/rest/base.rb

@@ -0,0 +1,88 @@
+require 'questrade_api/modules/util'
+require 'faraday'
+require 'json'
+
+module QuestradeApi
+  module REST
+    # @author Bruno Meira <goesmeira@gmail.com>
+    class Base
+      include QuestradeApi::Util
+
+      BASE_ENDPOINT = '/v1'.freeze
+      attr_accessor :connection, :raw_body, :endpoint,
+                    :authorization, :data
+
+      # Initialize an instance of QuestradeApi::REST::Base
+      #
+      # @param authorization [Object] to access API. Any object that responds to url and access_token.
+      def initialize(authorization)
+        @authorization = authorization
+
+        # TODO: Review this later
+        @connection =
+          self.class.connection(url: url,
+                                access_token: @authorization.access_token)
+      end
+
+      # @return [String]
+      def url
+        authorization.url
+      end
+
+      # Builds a new Faraday connection to access endpoint.
+      #
+      # @param params [Hash] for connection.
+      # @option params [String] :url of endpoint.
+      # @option params [String] :access_token to call endpoint.
+      #
+      # @return [Faraday] Object with attributes set up to call proper endpoint.
+      def self.connection(params = {})
+        Faraday.new(params[:url]) do |faraday|
+ #         faraday.response :logger
+          faraday.adapter Faraday.default_adapter
+          faraday.headers['Content-Type'] = 'application/json'
+          faraday.headers['Authorization'] = "Bearer #{params[:access_token]}"
+        end
+      end
+
+      protected
+
+      def build_data(data)
+        hash = hash_to_snakecase(data)
+        @data = OpenStruct.new(hash)
+      end
+
+      def build_attributes(response)
+        @raw_body = JSON.parse(response.body)
+      end
+
+      def get(params = {})
+        response = @connection.get do |req|
+          req.path = self.class.endpoint
+
+          params.each do |key, value|
+            req.params[key] = value
+          end
+        end
+
+        build_attributes(response) if response.status == 200
+
+        response
+      end
+
+      class << self
+        def all(params = {})
+          connection = connection(params)
+
+          connection.get do |req|
+            req.path = params[:endpoint]
+
+            params.fetch(:params, []).each do |key, value|
+              req.params[key] = value
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/questrade_api/rest/execution.rb

@@ -0,0 +1,59 @@
+require 'questrade_api/rest/base'
+
+module QuestradeApi
+  module REST
+    # @author Bruno Meira <goesmeira@gmail.com>
+    class Execution < QuestradeApi::REST::Base
+      attr_accessor :account_id
+
+      def initialize(params)
+        @account_id = params[:account_id]
+
+        @raw_body = params[:data]
+        build_data(params[:data]) if @raw_body
+      end
+
+      #
+      # Fetch account executions
+      #
+      # @param authorization [QuestradeApi::Authorization] with the authorized #access_token and #url.
+      # @param account_number [String] with the account the activities will be fetched
+      # @param params [Hash] with the range of dates the activities will be fetched
+      # @option params [String] :startTime The start time. ex: '2011-02-16T00:00:00.000000-05:00'
+      # @option params [String] :endTime The end time. ex: '2011-02-16T00:00:00.000000-05:00'
+      def self.all(authorization, account_number, params)
+
+        response = super(access_token: authorization.access_token,
+                         endpoint: endpoint(account_number),
+                         url: authorization.url,
+                         params: params)
+
+        result = OpenStruct.new(executions: [])
+
+        if response.status == 200
+          result.executions = parse_executions(account_number, response.body)
+        end
+
+        result
+      end
+
+      def self.endpoint(account_id)
+        "#{BASE_ENDPOINT}/accounts/#{account_id}/executions"
+      end
+
+      def self.parse_executions(account_id, body)
+        raw = JSON.parse(body)
+
+        executions = []
+
+        raw['executions'].each do |execution|
+          executions << new(account_id: account_id, data: execution)
+        end
+
+        executions
+      end
+
+      private_class_method :parse_executions
+    end
+  end
+end

data/lib/questrade_api/rest/market.rb

@@ -0,0 +1,42 @@
+require 'questrade_api/rest/base'
+
+module QuestradeApi
+  module REST
+    class Market < QuestradeApi::REST::Base
+      def initialize(params)
+        @raw_body = params[:data]
+        build_data(params[:data]) if @raw_body
+      end
+
+      def self.all(authorization)
+        response = super(access_token: authorization.access_token,
+                         endpoint: endpoint,
+                         url: authorization.url)
+
+        result = OpenStruct.new(markets: [])
+
+        result.markets = parse_markets(response.body) if response.status == 200
+
+        result
+      end
+
+      def self.endpoint
+        "#{BASE_ENDPOINT}/markets"
+      end
+
+      def self.parse_markets(body)
+        raw = JSON.parse(body)
+
+        markets = []
+
+        raw['markets'].each do |market|
+          markets << new(data: market)
+        end
+
+        markets
+      end
+
+      private_class_method :parse_markets
+    end
+  end
+end

data/lib/questrade_api/rest/order.rb

@@ -0,0 +1,58 @@
+require 'questrade_api/rest/base'
+
+module QuestradeApi
+  module REST
+    class Order < QuestradeApi::REST::Base
+      attr_accessor :account_id, :id
+
+      def initialize(authorization, params = {})
+        super(authorization)
+
+        @id = params[:id]
+        @account_id = params[:account_id]
+
+        @raw_body = params[:data]
+        build_data(params[:data]) if @raw_body
+      end
+
+      def self.all(authorization, account_number, params)
+
+        response = super(access_token: authorization.access_token,
+                         endpoint: endpoint(account_number),
+                         url: authorization.url,
+                         params: params)
+
+        result = OpenStruct.new(orders: [])
+
+        if response.status == 200
+          result.orders = parse_orders(authorization, account_number, response.body)
+        end
+
+        result
+      end
+
+      def endpoint
+        self.class.endpoint(account_id) + "/#{id}"
+      end
+
+      def self.endpoint(account_id)
+        "#{BASE_ENDPOINT}/accounts/#{account_id}/orders"
+      end
+
+      def self.parse_orders(authorization, account_id, body)
+        raw = JSON.parse(body)
+
+        orders = []
+
+        raw['orders'].each do |order|
+          orders << new(authorization,
+                        account_id: account_id, id: order['id'], data: order)
+        end
+
+        orders
+      end
+
+      private_class_method :parse_orders
+    end
+  end
+end

data/lib/questrade_api/rest/position.rb

@@ -0,0 +1,48 @@
+require 'questrade_api/rest/base'
+
+module QuestradeApi
+  module REST
+    class Position < QuestradeApi::REST::Base
+      attr_accessor :account_id
+
+      def initialize(params)
+        @account_id = params[:account_id]
+
+        @raw_body = params[:data]
+        build_data(params[:data]) if @raw_body
+      end
+
+      def self.all(authorization, account_number)
+        response = super(access_token: authorization.access_token,
+                         endpoint: endpoint(account_number),
+                         url: authorization.url)
+
+        result = OpenStruct.new(positions: [])
+
+        if response.status == 200
+          result.positions = parse_positions(account_number, response.body)
+        end
+
+        result
+      end
+
+      def self.endpoint(account_id)
+        "#{BASE_ENDPOINT}/accounts/#{account_id}/positions"
+      end
+
+      def self.parse_positions(account_id, body)
+        raw = JSON.parse(body)
+
+        positions = []
+
+        raw['positions'].each do |position|
+          positions << new(account_id: account_id, data: position)
+        end
+
+        positions
+      end
+
+      private_class_method :parse_positions
+    end
+  end
+end

data/lib/questrade_api/rest/time.rb

@@ -0,0 +1,26 @@
+require 'questrade_api/rest/base'
+
+module QuestradeApi
+  module REST
+    # @author Bruno Meira <goesmeira@gmail.com>
+    class Time < QuestradeApi::REST::Base
+      attr_reader :data
+
+      def initialize(authorization)
+        super(authorization)
+      end
+
+      def get
+        response = super
+
+        build_data(raw_body) if raw_body
+
+        response
+      end
+
+      def self.endpoint
+        "#{BASE_ENDPOINT}/time"
+      end
+    end
+  end
+end