em-nordnet 0.0.1

data/lib/em-nordnet/config.rb

@@ -0,0 +1,16 @@
+module Em
+  module Nordnet
+    class Config < Struct.new :url, :user, :password, :pem, :service
+      def credentials
+        @credentials ||= generate_credentials
+      end
+
+      private
+      def generate_credentials
+        auth = [user, password, Time.now.to_i*1000]
+        encoded = auth.map { |val| Base64.encode64 val.to_s.strip }.join(':')
+        Base64.encode64 OpenSSL::PKey::RSA.new(pem).public_encrypt encoded
+      end
+    end
+  end
+end

data/lib/em-nordnet/feed/connection.rb

@@ -0,0 +1,53 @@
+module Em
+  module Nordnet
+    module Feed
+      module Connection
+        attr_reader :session, :callbacks
+
+        def initialize(session)
+          @session = session
+          @callbacks = []
+        end
+
+        def on_tick &block
+          @callbacks << block
+        end
+
+        def subscribe args
+          send_data generate(:subscribe, args)
+        end
+
+        def connection_completed
+          start_tls
+        end
+
+        def ssl_handshake_completed
+          params = { session_key: session, service: Nordnet.config.service }
+          send_data generate(:login, params)
+        end
+
+        def receive_data json
+          callbacks.each { |callback| callback.call parse(json) }
+        end
+
+        def unbind
+          EventMachine::stop_event_loop
+        end
+
+        def send_data data
+          super "%s\n" % data # All writes must end with linefeed
+        end
+
+        private
+
+        def generate command, args ={}
+          MultiJson.dump cmd: command.to_s, args: args
+        end
+
+        def parse json
+          MultiJson.load(json, symbolize_keys: true)
+        end
+      end
+    end
+  end
+end

data/lib/em-nordnet/feed/dsl.rb

@@ -0,0 +1,56 @@
+module Em
+  module Nordnet
+    module Feed
+      class DSL
+        attr_reader :socket, :session, :callbacks
+
+        def initialize
+          @callbacks = initialize_callbacks
+
+          socket.on_tick { |data| run_callback data }
+        end
+
+        def socket
+          @socket = EventMachine::connect hostname, port, Connection, session
+        end
+
+        def session
+          @session ||= Nordnet.api.session
+        end
+
+        def on_heartbeat &block
+          add_callback :heartbeat, block
+        end
+
+        def add_callback type, block
+          @callbacks[type] << block
+        end
+
+        def types
+          raise NotImplementedError
+        end
+
+        def hostname
+          raise NotImplementedError
+        end
+
+        def port
+          raise NotImplementedError
+        end
+
+        private
+
+        def initialize_callbacks
+          types.inject heartbeat: [] do |callbacks, type|
+           callbacks[type] = []
+          end
+        end
+
+        def run_callback data
+          type, args = data[:cmd], data[:args]
+          callbacks[type].each { |callback| callback.call args }
+        end
+      end
+    end
+  end
+end

data/lib/em-nordnet/feed/private.rb

@@ -0,0 +1,27 @@
+module Em
+  module Nordnet
+    module Feed
+      class Private < Em::Nordnet::Feed::DSL
+        def types
+          [:trade, :order]
+        end
+
+        def hostname
+          Nordnet.api.private_feed[:hostname]
+        end
+
+        def port
+          Nordnet.api.private_feed[:port]
+        end
+
+        def on_trade &block
+          add_callback :trade, block
+        end
+
+        def on_order &block
+          add_callback :order, block
+        end
+      end
+    end
+  end
+end

data/lib/em-nordnet/feed/public.rb

@@ -0,0 +1,43 @@
+module Em
+  module Nordnet
+    module Feed
+      class Public < Em::Nordnet::Feed::DSL
+        def types
+          [:price, :depth, :trade, :index, :news, :trading_status]
+        end
+
+        def hostname
+          Nordnet.api.public_feed[:hostname]
+        end
+
+        def port
+          Nordnet.api.public_feed[:port]
+        end
+
+        def on_price &block
+          add_callback :price, block
+        end
+
+        def on_trade &block
+          add_callback :trade, block
+        end
+
+        def on_depth &block
+          add_callback :depth, block
+        end
+
+        def on_index &block
+          add_callback :index, block
+        end
+
+        def on_news &block
+          add_callback :news, block
+        end
+
+        def on_trading_status &block
+          add_callback :trading_status, block
+        end
+      end
+    end
+  end
+end

data/lib/em-nordnet/goliath/feed_plugin.rb

@@ -0,0 +1,25 @@
+module Em::Nordnet::Goliath
+  class FeedPlugin
+    @@connection = nil
+
+    class << self
+      def connection
+        @@connection
+      end
+    end
+
+    def initialize port, config, status, logger
+      @port, @config, @status, @logger = port, config, status, logger
+    end
+
+    def run
+      @@connection = feed_connection
+    end
+
+    private
+
+    def feed_connection
+      raise NotImplementedError
+    end
+  end
+end

data/lib/em-nordnet/goliath/private_feed.rb

@@ -0,0 +1,8 @@
+module Em::Nordnet::Goliath
+  class PrivateFeed < FeedPlugin
+    private
+    def feed_connection
+      Nordnet::Feed::Private.new
+    end
+  end
+end

data/lib/em-nordnet/goliath/public_feed.rb

@@ -0,0 +1,18 @@
+module Em::Nordnet::Goliath
+  class PublicFeed < FeedPlugin
+    class << self
+      def subscribe type, instrument, &block
+        instrument.subscribe_params(type).tap do |args|
+          connection.add_callback type, &block
+          connection.subscribe args
+        end
+      end
+    end
+
+    private
+
+    def feed_connection
+      Nordnet::Feed::Public.new
+    end
+  end
+end

data/lib/em-nordnet/instrument.rb

@@ -0,0 +1,27 @@
+module Em
+  module Nordnet
+    class Instrument
+      attr_accessor :id, :market_id, :currency, :shortname, :is_in_code, :longname, :ticksize_id
+
+      def self.search symbol, options={}
+        search_options = {query: symbol, type: 'A', country: ['SE','US']}.merge options
+        results = Nordnet.api.instrument_search(search_options)
+        results.map { |attributes| new attributes }
+      end
+
+      def initialize attributes={}
+        self.id          = attributes[:id] || attributes[:identifier]
+        self.market_id   = attributes[:market_id] || attributes[:marketID]
+        self.currency    = attributes[:currency]
+        self.shortname   = attributes[:shortname]
+        self.longname    = attributes[:longname]
+        self.is_in_code  = attributes[:is_in_code] || attributes[:isinCode]
+        self.ticksize_id = attributes[:ticksize_id] || attributes[:ticksizeID]
+      end
+
+      def subscribe_params type
+        { 't' => type.to_s, 'i' => id, 'm' => market_id }
+      end
+    end
+  end
+end

data/lib/em-nordnet/order.rb

@@ -0,0 +1,48 @@
+module Em
+  module Nordnet
+    class Order
+      BUY  = 'BUY'.freeze
+      SELL = 'SELL'.freeze
+
+      attr_accessor :id, :account, :instrument, :price, :volume, :status
+
+      class << self
+        def all account_id
+          orders = Nordnet.api.orders(account_id)
+          orders.map { |attributes| new attributes }
+        end
+
+        def buy attributes={}
+          symbol, price, volume = attributes[:symbol], attributes[:price], attributes[:volume]
+
+          instrument = Instrument.search(symbol).first
+          account = attributes[:account] || Account.default
+
+          order = Order.new account: account, instrument: instrument, price: price, volume: volume
+          order.buy!
+        end
+      end
+
+      def initialize attributes={}
+        self.id         = attributes[:id] || attributes[:orderID]
+        self.account    = attributes[:account]
+        self.instrument = attributes[:instrument]
+        self.price      = attributes[:price]
+        self.volume     = attributes[:volume]
+        self.status     = attributes[:status]
+      end
+
+      def buy!
+        self.status = Nordnet.api.create_order account.id,
+          identifier: instrument.id,
+          marketID: instrument.market_id,
+          price: price,
+          volume: volume,
+          side: BUY,
+          currency: instrument.currency
+
+        status
+      end
+    end
+  end
+end

data/lib/em-nordnet/version.rb

@@ -0,0 +1,5 @@
+module Em
+  module Nordnet
+    VERSION = "0.0.1"
+  end
+end

data/spec/em-nordnet/account_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe Em::Nordnet::Account do
+  let(:attributes) { { id: 123, alias: 'alias', default: true } }
+  before { Em::Nordnet.stub(:api).and_return stub(accounts: [attributes]) }
+
+  subject { Em::Nordnet::Account.new attributes }
+
+  describe 'initialization' do
+    its(:id)      { should == 123     }
+    its(:alias)   { should == 'alias' }
+    its(:default) { should be_true    }
+  end
+
+  describe '.all' do
+    it 'should returns a collection of accounts fetched with the API' do
+      Em::Nordnet::Account.all.first.should be_instance_of(Em::Nordnet::Account)
+    end
+    it 'should be memoized' do
+      Em::Nordnet::Account.all.should be Em::Nordnet::Account.all 
+    end
+  end
+
+  it '.default', 'should return the account that is set to default' do
+    account = Em::Nordnet::Account.default
+    account.should be_instance_of Em::Nordnet::Account
+    account.default.should be_true
+  end
+
+  it '#orders', 'should return a collection of orders connected to the account' do
+    Em::Nordnet::Order.should_receive(:all).with(123)
+    subject.orders
+  end
+end

data/spec/em-nordnet/api_spec.rb

@@ -0,0 +1,179 @@
+require 'spec_helper'
+
+describe Em::Nordnet::Api, type: 'api authenticated' do
+  let(:api) { Em::Nordnet::Api.new }
+  subject { api }
+
+  let(:account_id) { 4711 }
+
+  describe 'initialization' do
+    its(:credentials) { should_not be_nil }
+    its(:session)     { should_not be_nil }
+    its(:expires_in)  { should_not be_nil }
+  end
+
+  describe '#login' do
+    its(:session)     { should == 'cf147c690f65fe1068f40ef23f23648ebf8c7f02' }
+    its(:expires_in)  { should == 300 }
+    it { api.login.should == login_result }
+  end
+
+  describe '#touch' do
+    before { stub_touch(api.session) }
+    it { api.touch.should == touch_result }
+  end
+
+  describe '#realtime_access' do
+    before { stub_realtime_access }
+    it { api.realtime_access.should == realtime_access_result }
+  end
+
+  describe '#news_sources' do
+    before { stub_news_sources }
+    it { api.news_sources.should == news_sources_result }
+  end
+
+  describe '#news_items' do
+    let(:params) { {query: 'ERIC'} }
+    before { stub_news_items params }
+    it { api.news_items.should == news_items_result }
+  end
+
+  describe '#news_item' do
+    let(:news_item_id) { 213 }
+    before { stub_news_item news_item_id }
+    it { api.news_item(news_item_id).should == news_item_result }
+  end
+
+  describe '#accounts' do
+    before { stub_accounts }
+    it { api.accounts.should == accounts_result }
+  end
+
+  describe '#account' do
+    before { stub_account account_id }
+    it { api.account(account_id).should == account_result }
+  end
+
+  describe '#ledgers' do
+    before { stub_ledgers account_id }
+    it { api.ledgers(account_id).should == ledgers_result }
+  end
+
+  describe '#positions' do
+    before { stub_positions account_id }
+    it { api.positions(account_id).should == positions_result }
+  end
+
+  describe '#orders' do
+    before { stub_orders account_id }
+    it { api.orders(account_id).should == orders_result }
+  end
+
+  describe '#trades' do
+    before { stub_trades account_id }
+    it { api.trades(account_id).should == trades_result }
+  end
+
+  describe '#instrument_search' do
+    let(:params) { {query: 'abb', type: 'A', country: 'SE'} }
+    before { stub_instrument_search params }
+    it { api.instrument_search(params).should == instrument_search_result }
+  end
+
+  describe '#instrument_lookup' do
+    let(:params) { {identifier: 101, marketID: 11} }
+    before { stub_instrument_lookup params }
+    it { api.instrument_lookup(params).should == instrument_lookup_result }
+  end
+
+  describe '#multiple_instrument_lookup' do
+    let(:list) { "101,11;102,11;" }
+    before { stub_multiple_instrument_lookup list }
+    it { api.multiple_instrument_lookup(list).should == multiple_instrument_lookup_result }
+  end
+
+  describe '#chart_data' do
+    let(:params) { {identifier: 101, marketID: 11} }
+    before { stub_chart_data params }
+    it { api.chart_data(params).should == chart_data_result }
+  end
+
+  describe '#lists' do
+    before { stub_lists }
+    it { api.lists.should == lists_result }
+  end
+
+  describe '#list_items' do
+    let(:list_id) { 123 }
+    before { stub_list_items list_id }
+    it { api.list_items.should == list_items_result }
+  end
+
+  describe '#markets' do
+    before { stub_markets }
+    it { api.markets.should == markets_result }
+  end
+
+  describe '#trading_days' do
+    let(:market_id) { 32 }
+    before { stub_trading_days market_id }
+    it { api.trading_days(market_id).should == trading_days_result }
+  end
+
+  describe '#indices' do
+    before { stub_indices }
+    it { api.indices.should == indices_result }
+  end
+
+  describe '#ticksizes' do
+    let(:instrument_id) { 11002 }
+    before { stub_ticksizes instrument_id }
+    it { api.ticksizes(instrument_id).should == ticksizes_result }
+  end
+
+  describe '#countries' do
+    let(:derivative_type) { 'WNT' }
+    before { stub_countries derivative_type }
+    it { api.countries(derivative_type).should == countries_result }
+  end
+
+  describe '#underlyings' do
+    let(:derivative_type) { 'WNT' }
+    let(:country) { 'SE' }
+    before { stub_underlyings derivative_type, country }
+    it { api.underlyings(derivative_type, country).should  == underlyings_result }
+  end
+
+  describe '#derivatives' do
+    let(:derivative_type) { 'WNT' }
+    let(:params) { {identifier: 101, marketID: 11} }
+    before { stub_derivatives derivative_type, params }
+    it { api.derivatives(derivative_type, params).should == derivatives_result }
+  end
+
+  describe '#related_markets' do
+    let(:params) { {identifier: 101, marketID: 11} }
+    before { stub_related_markets params }
+    it { api.related_markets(params).should == related_markets_result }
+  end
+
+  describe '#create_order' do
+    let(:params) { { identifier: 101, marketID: 11, price: 60, volume: 200, side: 'BUY', currency: 'SEK' } }
+    before { stub_create_order account_id, params }
+    it { api.create_order(account_id, params).should == create_order_result }
+  end
+
+  describe '#modify_order' do
+    let(:order_id) { 6670 }
+    let(:params) { { identifier: 101, marketID: 11, price: 100, volume: 200, side: 'BUY', currency: 'SEK' } }
+    before { stub_modify_order account_id, order_id, params }
+    it { api.modify_order(account_id, order_id, params).should == modify_order_result }
+  end
+
+  describe '#destroy_order' do
+    let(:order_id) { 6670 }
+    before { stub_destroy_order account_id, order_id }
+    it { api.destroy_order(account_id, order_id).should == destroy_order_result }
+  end
+end