excoin 0.0.1

data/lib/account/deposit.rb

@@ -0,0 +1,20 @@
+class Excoin::Account::Wallet::Deposit
+  attr_reader :timestamp, :currency, :id, :address,
+              :amount, :confirmations, :confirmed
+
+  def initialize(deposit_data)
+    begin
+      @timestamp = Time.parse(deposit_data['timestamp'])
+      @currency = deposit_data['currency']
+      @id = deposit_data['txid']
+      @address = deposit_data['address']
+      @amount = BigDecimal.new(deposit_data['amount'])
+      @confirmations = deposit_data['confirmations']
+      @confirmed = deposit_data['confirmed']
+    rescue
+      puts "Error in Excoin::Account::Deposit.initialize"
+      puts deposit_data
+    end
+  end
+
+end

data/lib/account/order.rb

@@ -0,0 +1,43 @@
+class Excoin::Account::Order
+  attr_reader :currency, :commodity, :type, :id, :timestamp, :price,
+              :commodity_amount, :currency_amount, :status
+
+  def initialize(order_data)
+    self.update(order_data)
+  end
+
+  def update(order_data)
+    begin
+      unless order_data['currency'] and order_data['commodity']
+        order_data.merge!({"currency" => order_data['id'].split("-").first, "commodity" => order_data['id'].split("-")[1]})
+      end
+      @currency ||= order_data['currency']
+      @commodity ||= order_data['commodity']
+      @type ||= order_data['type']
+      @id ||= order_data['id']
+      @timestamp ||= Time.parse(order_data['timestamp'])
+      @price = BigDecimal.new(order_data['price'])
+      @currency_amount = BigDecimal.new(order_data['currency_amount'])
+      @commodity_amount = BigDecimal.new(order_data['commodity_amount'])
+      @status = order_data['status']
+    rescue
+      puts "Error in Excoin::Account::Order.update"
+      puts order_data
+    end
+  end
+
+  def exchange
+    Excoin.market.exchange(@currency + @commodity)
+  end
+
+  def refresh
+    order_data = Excoin.api.account_view_order(self.id)
+    self.update(order_data)
+  end
+
+  def cancel
+    order_data = Excoin.api.account_cancel_order(self.id)
+    self.update(order_data)
+  end
+
+end

data/lib/account/orders.rb

@@ -0,0 +1,138 @@
+class Excoin::Account::Orders < Array
+
+  def initialize
+    self.refresh
+  end
+
+  def update(exchange_name = nil)
+    begin
+      unless exchange_name
+        all_orders = populate_all_orders
+        all_orders.each do |exchange_order_set|
+          self.select{|h| h['exchange_name'] == exchange_order_set['exchange_name']}.first.merge!(exchange_order_set)
+        end
+      else
+        exchange = Excoin.market.exchange(exchange_name)
+        exchange_order_data = self.get(exchange.currency, exchange.commodity)
+        exchange_orders = self.process_orders_by_exchange(exchange_order_data)
+        self.select{|h| h['currency'] == currency and h['commodity'] == commodity}.first.merge!(exchange_orders)
+      end
+    rescue
+      puts "Error in Excoin::Account::Orders.update"
+      puts exchange_order_data
+    end
+  end
+
+  def refresh
+    self.clear
+    all_orders = self.populate_all_orders
+    all_orders.each do |exchange_order_set|
+      self.push(exchange_order_set)
+    end
+  end
+
+  def all
+    self.collect{|order_set| order_set.select{|k,v| k =~ Regexp.new("_orders")}.values}.collect{|orders| orders}.flatten
+  end
+
+  def add(order)
+    begin
+      self.select{|exchange_order_set| exchange_order_set.has_value?(order.currency + order.commodity)}[0].select{|k,v| k =~ Regexp.new(order.type.downcase)}[order.type.downcase + "_orders"] << order
+    rescue
+      puts "Error in Excoin::Account::Orders.add"
+      puts order
+    end
+  end
+
+  def delete(order_data)
+    begin
+      self.select{|exchange_order_set| exchange_order_set.has_value?(order_data['currency'] + order_data['commodity'])}[0].select{|k,v| k =~ Regexp.new(order_data['type'].downcase)}[order_data['type'].downcase + "_orders"].delete_at(self.select{|exchange_order_set| exchange_order_set.has_value?(order_data['currency'] + order_data['commodity'])}[0].select{|k,v| k =~ Regexp.new(order_data['type'].downcase)}[order_data['type'].downcase + "_orders"].find_index{|order| order.id == order_data['id']})
+    rescue
+      puts "Error in Excoin::Account::Orders.delete"
+      puts order_data
+    end
+  end
+
+  def filter(attr, value, operator = :==)
+    orders_by_attr = Array.new
+    if attr == "currency" or attr == "commodity" or attr == "exchange_name"
+      self.select{|h| h[attr] == value}.each do |h|
+        h.select{|k,v| k =~ Regexp.new("_orders")}.each_value do |orders|
+          orders.each do |order|
+            orders_by_attr << order
+          end
+        end
+      end
+    else
+      self.each do |h|
+        if attr == "type"
+          h.select{|k,v| k =~ Regexp.new(value.upcase)}.each_value do |orders|
+            orders.each do |order|
+              orders_by_attr << order
+            end
+          end
+        else
+          h.select{|k,v| k =~ Regexp.new("_orders")}.each_value do |orders|
+            orders.each do |order|
+              value = BigDecimal.new(value)
+              if order.send(attr).send(operator, value)
+                orders_by_attr << order
+              end
+            end
+          end
+        end
+      end
+    end
+    return orders_by_attr
+  end
+
+  def count(attr = nil, value = nil, operator = :==)
+    if attr
+      return self.filter(attr, value, operator).size
+    else
+      count = 0
+      self.each do |h|
+      # maybe this can be redone with inject
+        h.select{|k,v| k =~ /_orders/}.each_pair do |k,v|
+          count += v.size
+        end
+      end
+      return count
+    end
+  end
+
+  protected
+
+    def get(currency = nil, commodity = nil, type = nil)
+      Excoin.api.account_open_orders(currency, commodity, type)
+    end
+
+    def process_orders_by_exchange(exchange_order_data)
+      begin
+        currency = exchange_order_data.select{|k,v| k == 'currency'}
+        commodity = exchange_order_data.select{|k,v| k == 'commodity'}
+        exchange_orders = {"exchange_name" => currency['currency'] + commodity['commodity']}.merge(currency).merge(commodity)
+        exchange_order_data['orders'].each do |hash_by_type|
+          orders_by_type = Array.new
+          type = hash_by_type.select{|k,v| k == 'type'}
+          hash_by_type['orders'].each do |o|
+            o.merge!(type).merge!(currency).merge!(commodity)
+            order = Excoin::Account::Order.new(o)
+            orders_by_type << order
+          end
+          exchange_orders.merge!({ "#{type['type'].downcase}_orders" => orders_by_type})
+        end
+        return exchange_orders
+      rescue
+        puts "Error in Excoin::Account::Orders.process_orders_by_exchange"
+        puts exchange_order_data
+      end
+    end
+
+  def populate_all_orders
+    order_data = self.get
+    orders = order_data.collect{|exchange_order_data| self.process_orders_by_exchange(exchange_order_data)}
+    return orders
+  end
+
+end

data/lib/account/trade.rb

@@ -0,0 +1,26 @@
+class Excoin::Account::Trade
+  attr_reader :timestamp, :currency, :commodity, :type, :price, :sent,
+              :received, :fee, :net_received
+
+  def initialize(trade_data)
+    begin
+      @timestamp = Time.parse(trade_data['timestamp'])
+      @currency = trade_data['currency']
+      @commodity = trade_data['commodity']
+      @type = trade_data['type']
+      @price = BigDecimal.new(trade_data['price'])
+      @sent = BigDecimal.new(trade_data['sent'])
+      @received = BigDecimal.new(trade_data['received'])
+      @fee = BigDecimal.new(trade_data['fee'])
+      @net_received = BigDecimal.new(trade_data['net_received'])
+    rescue
+      puts "Error in Excoin::Account::Trade.initialize"
+      puts trade_data
+    end
+  end
+
+  def exchange
+    Excoin.market.exchange(@currency + @commodity)
+  end
+
+end

data/lib/account/trades.rb

@@ -0,0 +1,59 @@
+class Excoin::Account::Trades < Array
+
+  def initialize
+    self.update
+  end
+
+  def update(count = 100)
+    self.clear
+    recent_trade_data = self.get(count)
+    begin
+      recent_trade_data['trades'].each do |trade_data|
+        trade = Excoin::Account::Trade.new(trade_data)
+        self.push(trade)
+      end
+    rescue
+      puts "Error in Excoin::Account::Trades.update"
+      puts recent_trade_data
+    end
+  end
+
+  def buys
+    self.select{|trade| trade.type == "BUY"}
+  end
+
+  def sells
+    self.select{|trade| trade.type == "SELL"}
+  end
+
+  def highest(type = nil)
+    unless type
+      self.max_by{|trade| trade.price}
+    else
+      self.select{|trade| trade.type == type.upcase}.max_by{|trade| trade.price}
+    end
+  end
+
+  def lowest(type = nil)
+    unless type
+      self.min_by{|trade| trade.price}
+    else
+      self.select{|trade| trade.type == type.upcase}.min_by{|trade| trade.price}
+    end
+  end
+
+  def add(trade_data)
+    self.insert(0, Excoin::Account::Trade.new(trade_data))
+  end
+
+  def trim(number)
+    self.pop(number)
+  end
+
+  protected
+
+    def get(count = 100)
+      Excoin.api.account_trades(count)
+    end
+
+end

data/lib/account/wallet.rb

@@ -0,0 +1,72 @@
+class Excoin::Account::Wallet
+  attr_reader :status, :currency, :deposit_address, :confirmed_balance,
+              :available_balance, :order_balance,
+              :pending_deposit_balance, :pending_withdrawal_balance,
+              :deposits, :withdrawals
+
+  def initialize(active, wallet_data)
+    begin
+      if active
+        @status = "active"
+        @currency = wallet_data['currency']
+        @deposits = Hash.new
+        @withdrawals = Hash.new
+        @deposit_address = wallet_data['address']
+        @confirmed_balance = BigDecimal.new(wallet_data['confirmed_balance'])
+        @available_balance = BigDecimal.new(wallet_data['available_balance'])
+        @order_balance = BigDecimal.new(wallet_data['order_balance'])
+        @pending_deposit_balance = BigDecimal.new(wallet_data['pending_deposit_balance'])
+        @pending_withdrawal_balance = BigDecimal.new(wallet_data['pending_withdrawal_balance'])
+      else
+        @status = "inactive"
+        @currency = wallet_data['currency']
+        @deposit_address = wallet_data['address']
+      end
+    rescue
+      puts "Error in Excoin::Account::Wallet.initialize"
+      puts wallet_data
+    end
+  end
+
+  def update(wallet_data)
+    begin
+      if wallet_data['address']
+        @deposit_address = wallet_data['address']
+      end
+      @confirmed_balance = BigDecimal.new(wallet_data['confirmed_balance'])
+      @available_balance = BigDecimal.new(wallet_data['available_balance'])
+      @order_balance = BigDecimal.new(wallet_data['order_balance'])
+      @pending_deposit_balance = BigDecimal.new(wallet_data['pending_deposit_balance'])
+      @pending_withdrawal_balance = BigDecimal.new(wallet_data['pending_withdrawal_balance'])
+    rescue
+      puts "Error in Excoin::Account::Wallet.update"
+      puts wallet_data
+    end
+  end
+
+  def unconfirmed_deposits
+    return @deposits.select{|id, deposit_object| deposit_object.confirmed == false}
+  end
+
+  def unconfirmed_withdrawals
+    return @withdrawals.select{|id, withdrawal_object| withdrawal_object.confirmed == false}
+  end
+
+  def add_deposit(deposit_data)
+    @deposits.merge!({deposit_data['txid'] => Deposit.new(deposit_data)})
+  end
+
+  def add_withdrawal(withdrawal_data)
+    @withdrawals.merge!({withdrawal_data['id'] => Withdrawal.new(withdrawal_data)})
+  end
+
+  def withdraw(address, amount)
+    if BigDecimal.new(amount) <= self.available_balance
+      withdrawal_data = Excoin.api.account_withdraw(self.currency, address, amount)
+      Excoin.account.add_withdrawal(withdrawal_data)
+    else
+      puts "Insufficient funds for withdrawal"
+    end
+  end
+
+end

data/lib/account/withdrawal.rb

@@ -0,0 +1,27 @@
+class Excoin::Account::Wallet::Withdrawal
+  attr_reader :id, :timestamp, :currency, :address,
+              :amount, :confirmed
+
+  def initialize(withdrawal_data)
+    begin
+      @id = withdrawal_data['id']
+      @timestamp = Time.parse(withdrawal_data['timestamp'])
+      @currency = withdrawal_data['currency']
+      @address = withdrawal_data['address']
+      @amount = BigDecimal.new(withdrawal_data['amount'])
+      @confirmed = withdrawal_data['confirmed']
+    rescue
+      puts "Error in Excoin::Account::Withdrawal.initialize"
+      puts withdrawal_data
+    end
+  end
+
+## to be implemented in API in the future
+#
+#  def cancel_withdrawal(withdrawal_id)
+#  end
+#
+#  def initiate_withdrawal
+#  end
+
+end

data/lib/exchange/candlestick_chart.rb

@@ -0,0 +1,33 @@
+class Excoin::Market::Exchange::CandlestickChart
+  attr_reader :currency, :commodity, :datapoints
+
+  def initialize(exchange_name)
+    @exchange_name = exchange_name
+    exchange = self.exchange
+
+    @currency = exchange.currency
+    @commodity = exchange.commodity
+
+    @datapoints = Array.new
+    self.update
+  end
+
+  def update
+    @datapoints.clear
+    chart_data = self.get
+    chart_data.each do |point|
+      datapoint = DataPoint.new(point)
+      @datapoints << datapoint
+    end
+  end
+
+  def exchange
+    return Excoin.market.exchange(@exchange_name)
+  end
+
+  protected
+    def get
+      Excoin.api.exchange_candlestick_chart_data(@currency, @commodity)
+    end
+
+end

data/lib/exchange/candlestick_data.rb

@@ -0,0 +1,20 @@
+class Excoin::Market::Exchange::CandlestickChart::DataPoint
+  attr_reader :timestamp, :open, :close, :high, :low, :commodity_volume,
+              :currency_volume
+
+  def initialize(exchange_data)
+    begin
+      @timestamp = Time.parse(exchange_data['timestamp'])
+      @open = BigDecimal.new(exchange_data['open'])
+      @close = BigDecimal.new(exchange_data['close'])
+      @high = BigDecimal.new(exchange_data['high'])
+      @low = BigDecimal.new(exchange_data['low'])
+      @commodity_volume = BigDecimal.new(exchange_data['commodity_volume'])
+      @currency_volume = BigDecimal.new(exchange_data['currency_volume'])
+    rescue
+      puts "Error in Excoin::Market::Exchange::CandlestickChart::Datapoint"
+      puts exchange_data
+    end
+  end
+
+end