}// ProcessOrderAdded
//
//
private void ProcessOrderDeleted(TT.OrderDeletedEventArgs eventArg)
{
Log.BeginEntry(LogLevel.Minor, "ProcessOrderDeleted:");
OrderBookEventArgs outgoingEventArg = null; // outgoing event, if needed.
TT.Order ttOrder = eventArg.OldOrder;
InstrumentName name;
OrderBook baseBook;
if (m_TTKey2Name.TryGetValue(ttOrder.InstrumentKey, out name) && this.TryEnterBookWrite(name, out baseBook))
{
OrderBookTT book = (OrderBookTT)baseBook;
string tag;
if (book.m_TagTT2Bre.TryGetValue(ttOrder.SiteOrderKey, out tag))
{
Order deletedOrder;
if (book.TryDeleteOrder(tag, out deletedOrder))
{
outgoingEventArg = new OrderBookEventArgs(this, name, OrderBookEventArgs.EventTypes.DeletedOrder); // Load out-going eventArg
outgoingEventArg.Order = deletedOrder;
Log.AppendEntry(" Deleted order {0} to book {1}.", deletedOrder, book);
}
}
this.ExitBookWrite(baseBook);
}
Log.EndEntry();
if (outgoingEventArg != null)
{
OnBookChanged(outgoingEventArg);
}
}// ProcessOrderDelete()
protected void OnChanged(object sender, OrderBookEventArgs e)
{
if (Changed != null)
{
Changed(this, EventArgs.Empty);
}
}
private void OrderBookWebSocketHandler(ExchangeName exName, OrderBookEventArgs args)
{
var instrument = _wsInstruments[args.Instrument1];
var exchange = _wsExchanges[exName];
if (!exchange.ValidOrderPrices(args, instrument))
{
return;
}
var priceArgs = new ExchangePricesEventArgs
{
CreatedAt = DateTime.UtcNow,
Timestamp = args.Timestamp,
Instrument1 = args.Instrument1,
Instrument2 = args.Instrument2,
OrderId = args.OrderId,
Exchange = exchange.GetExchangeName(),
IsOrderDeleted = args.IsOrderDeleted
};
Task.Run(() => _dbRepo.SaveOrderBook(priceArgs, args.OrderBook));
instrument.InitExchangePrice(exchange, priceArgs);
OnExchangePrices(null, priceArgs);
}
private static void OnOrderBookChanged(object sender, OrderBookEventArgs e)
{
Ticker t = ((OrderBook)sender).Owner;
OrderBookEntry ask = t.OrderBook.Asks[0];
OrderBookEntry bid = t.OrderBook.Bids[0];
}
}// OrderHub_BookCreated().
//
//
// **** OrderHub_BookChanged() ****
//
private void OrderHub_BookChanged(object sender, EventArgs eventArgs)
{
OrderBookEventArgs eventArg = (OrderBookEventArgs)eventArgs;
OrderBookDepthListView view;
if (m_OrderBookViews.TryGetValue(eventArg.Instrument, out view))
{
view.OrderHub_BookChanged(sender, eventArgs);
}
}
// *****************************************************************
// **** Event Handlers ****
// *****************************************************************
//
//
//
// **** OrderHub_BookChanged() ****
//
public void OrderHub_BookChanged(object sender, EventArgs eventArgs)
{
if (this.InvokeRequired)
{
this.Invoke(new EventHandler(OrderHub_BookChanged), new object[] { sender, eventArgs });
}
else
{
OrderBookEventArgs eventArg = (OrderBookEventArgs)eventArgs;
Order order = eventArg.Order;
if (eventArg.EventType == OrderBookEventArgs.EventTypes.NewOrder)
{
m_OrderBook.TryAddOrder(order);
GLItem item = new GLItem();
m_GList[order.Side].Items.Add(item);
if (order.Side == 1)
{
item.SubItems[0].Text = order.IPrice.ToString();
item.SubItems[1].Text = order.Qty.ToString();
item.SubItems[2].ImageIndex = 0;
//item.SubItems[2].ImageAlignment = HorizontalAlignment.Center;
item.SubItems[3].Text = "Default";
}
else
{
item.SubItems[3].Text = order.IPrice.ToString();
item.SubItems[2].Text = order.Qty.ToString();
item.SubItems[1].ImageIndex = 0;
//item.SubItems[2].ImageAlignment = HorizontalAlignment.Center;
item.SubItems[0].Text = "Default";
}
}
else if (eventArg.EventType == OrderBookEventArgs.EventTypes.DeletedOrder)
{
m_OrderBook.TryDeleteOrder(order.Tag, out order);
GLItem foundItem = null;
foreach (GLItem item in m_GList[order.Side].Items)
{
if (item.Text == order.Tag)
{
foundItem = item;
}
}
if (foundItem != null)
{
m_GList[order.Side].Items.Remove(foundItem);
}
}
else if (eventArg.EventType == OrderBookEventArgs.EventTypes.DeletedOrder)
{
//m_OrderBook.TryDeleteOrder(eventArg.Order);
}
}
}//OrderHub_BookChanged()
//
// **** OrderHub_BookDeleted() ****
//
void OrderHub_BookDeleted(object sender, EventArgs eventArgs)
{
if (this.InvokeRequired)
{
this.Invoke(new EventHandler(OrderHub_BookCreated), new object[] { sender, eventArgs });
}
else
{
OrderBookEventArgs eventArg = (OrderBookEventArgs)eventArgs;
}
}
private void SubscribeOrder(Channel channel, string eventName, EventHandler <OrderBookEventArgs> handler, OrderState state)
{
channel.Bind(eventName, json =>
{
var time = DateTime.UtcNow;
var order = JsonConvert.DeserializeObject <BitstampOrderBook>(json);
var orderBook = new OrderBookEventArgs(order, state);
orderBook.CreatedAt = time;
handler(this, orderBook);
});
}
}//UpdateView()
//
//
//
//
//
#endregion//Private Methods
#region External Event Handlers
// *****************************************************************
// **** Event Handlers ****
// *****************************************************************
//
//
//
// **** OrderHub_BookChanged() ****
//
void OrderHub_BookChanged(object sender, EventArgs eventArgs)
{
if (this.InvokeRequired)
{
this.Invoke(new EventHandler(OrderHub_BookChanged), new object[] { sender, eventArgs });
}
else
{
OrderBookEventArgs eventArg = (OrderBookEventArgs)eventArgs;
if (m_OrderBooks.TryUpdate(eventArg))
{
UpdateView(eventArg);
}
}
}
//
//
// **** OrderHub_BookCreated() ****
//
private void OrderHub_BookCreated(object sender, EventArgs eventArgs)
{
if (this.InvokeRequired)
{
this.Invoke(new EventHandler(OrderHub_BookCreated), new object[] { sender, eventArgs });
}
else
{
OrderBookEventArgs eventArg = (OrderBookEventArgs)eventArgs;
if (!m_OrderBookViews.ContainsKey(eventArg.Instrument))
{
CreateOrderBookView(eventArg);
}
}
}// OrderHub_BookCreated().
}// ProcessMarketFoundResource()
//
//
//
#endregion//Private HubEvent Handler
#region Private Order Update Handlers
// *****************************************************************
// **** Private Order Update Handlers ****
// *****************************************************************
//
//
private void ProcessOrderAdded(TT.OrderAddedEventArgs eventArg)
{
Log.BeginEntry(LogLevel.Minor, "ProcessOrderAdded:");
OrderBookEventArgs outgoingEventArg = null;
TT.Order ttOrder = eventArg.Order;
InstrumentName name;
OrderBook book;
if (m_TTKey2Name.TryGetValue(ttOrder.InstrumentKey, out name) && this.TryEnterBookWrite(name, out book))
{ // We know this TTKey, and have an associated book!
OrderBookTT booktt = (OrderBookTT)book;
Order newOrder = booktt.CreateNewOrder();
int mktSign = Misty.Lib.Utilities.QTMath.BuySign;
newOrder.Side = Misty.Lib.Utilities.QTMath.BuySide;
if (ttOrder.BuySell == TT.BuySell.Sell)
{
mktSign = Misty.Lib.Utilities.QTMath.SellSign;
newOrder.Side = Misty.Lib.Utilities.QTMath.SellSide;
}
newOrder.Qty = mktSign * ttOrder.WorkingQuantity.ToInt();
newOrder.IPrice = (int)Math.Round(ttOrder.LimitPrice.ToDouble() / book.MinimumPriceTick);
int intPrice = ttOrder.LimitPrice.ToInt(); // for debugging
if (book.TryAddOrder(newOrder))
{
booktt.m_TagBre2TT.Add(newOrder.Tag, ttOrder.SiteOrderKey);
booktt.m_TagTT2Bre.Add(ttOrder.SiteOrderKey, newOrder.Tag);
outgoingEventArg = new OrderBookEventArgs(this, name, OrderBookEventArgs.EventTypes.NewOrder); // Load out-going eventArg
outgoingEventArg.Order = newOrder;
Log.AppendEntry(" Added new order {0} to book {2}.", newOrder, ttOrder, book);
}
else
{
Log.AppendEntry(" Failed to add order {0} to book {2}. Store order for later.", newOrder, ttOrder, book);
StoreTTEvent(eventArg, ttOrder.InstrumentKey);
}
this.ExitBookWrite(book);
}
else
{ // We have no book for this instrument.
StoreTTEvent(eventArg, ttOrder.InstrumentKey); // Store order and request mkt details.
}
Log.EndEntry();
if (outgoingEventArg != null)
{
OnBookChanged(outgoingEventArg);
}
}// ProcessOrderAdded
public void SubscribeOrderBook(OrderBookEventArgs orderBookEventArgs)
{
if (orderBookEventArgs == null)
{
throw new ArgumentNullException(nameof(orderBookEventArgs));
}
var message = JsonConvert.SerializeObject(orderBookEventArgs.OrderBook);
var strategyNotification = new StrategyNotification {
Name = Strategy.Name, Message = message, NotificationLevel = NotificationLevel.OrderBook
};
StrategyOrderBookNotification(new StrategyNotificationEventArgs {
StrategyNotification = strategyNotification
});
}
public bool ValidOrderPrices(OrderBookEventArgs args, Instrument ins)
{
double expectedAmount;
var bidOrder = ins.CreateBidOrder(this, out expectedAmount);
var askOrder = ins.CreateAskOrder(this, out expectedAmount);
GetPrice(args.OrderBook.Bids, args.OrderBook.Asks, expectedAmount, bidOrder, askOrder);
if (bidOrder.Price == 0 && askOrder.Price == 0)
{
return(false);
}
//if (!ins.CheckConstraint(bidOrder.Price, askOrder.Price, CurrencyRate))
// return false;
return(ins.ValidOrderPrices(this, bidOrder, askOrder));
}
}// InitializeListView()
//
//
//
// **** TryCreate() ****
//
/// <summary>
/// This must be called by the UI thread.
/// </summary>
public static bool TryCreate(OrderBookEventArgs eventArgs, out OrderBookDepthListView newView)
{
// Validate
newView = null;
if (eventArgs.EventType != OrderBookEventArgs.EventTypes.CreatedBook)
{
return(false);
}
// Create object
OrderBook newBook;
bool isSucessful = OrderBook.TryCreate(eventArgs, out newBook);
if (isSucessful)
{
newView = new OrderBookDepthListView();
newView.m_OrderBook = newBook;
}
return(isSucessful);
}//TryCreate()
}// AddHub()
//
//
//
//
//
#endregion//Public Methods
#region Private Methods
// *****************************************************************
// **** Private Methods ****
// *****************************************************************
//
//
// **** UpdateView() ****
//
private void UpdateView(OrderBookEventArgs eventArg)
{
string s;
switch (eventArg.EventType)
{
case OrderBookEventArgs.EventTypes.NewOrder:
s = eventArg.Order.ToString();
m_OrderDetails.Add(eventArg.Order, s);
m_OrderList.Add(s);
break;
case OrderBookEventArgs.EventTypes.DeletedOrder:
if (m_OrderDetails.TryGetValue(eventArg.Order, out s) && m_OrderList.Contains(s))
{
m_OrderList.Remove(s);
}
break;
}
}//UpdateView()
protected override void OnMessage(object sender, MessageEventArgs e)
{
var obj = JsonConvert.DeserializeObject <XBtcResponse>(e.Data);
if (String.Compare(obj.Response, "Login") == 0)
{
if (String.Compare(obj.Result.Info, "ok", true) != 0)
{
Log.WriteError(obj.Result.Info, (int)GetExchangeName());
}
}
else if (String.Compare(obj.Response, "FeedSubscribe") == 0)
{
//...
}
else if (String.Compare(obj.Response, "FeedTick") == 0)
{
var args = new OrderBookEventArgs(obj.Result);
if (obj.Result.Symbol == "BTCUSD" && _btcOrderBookHandler != null)
{
_btcOrderBookHandler(this, args);
}
else if (obj.Result.Symbol == "LTCUSD" && _ltcOrderBookHandler != null)
{
_ltcOrderBookHandler(this, args);
}
else if (obj.Result.Symbol == "BCHUSD" && _bchOrderBookHandler != null)
{
_bchOrderBookHandler(this, args);
}
else if (obj.Result.Symbol == "ETHUSD" && _ethOrderBookHandler != null)
{
_ethOrderBookHandler(this, args);
}
else if (obj.Result.Symbol == "DSHUSD" && _dashOrderBookHandler != null)
{
_dashOrderBookHandler(this, args);
}
}
}
//
//
#endregion//Constructors
#region no Properties
// *****************************************************************
// **** Properties ****
// *****************************************************************
//
//
#endregion//Properties
#region no Public Methods
// *****************************************************************
// **** Public Methods ****
// *****************************************************************
//
//
//
//
//
//
#endregion//Public Methods
#region no Private Methods
// *****************************************************************
// **** Private Methods ****
// *****************************************************************
//
//
//
// **** CreateOrderBookView() ****
//
private void CreateOrderBookView(OrderBookEventArgs eventArg)
{
int nColumns = 2;
OrderBookDepthListView view;
if (OrderBookDepthListView.TryCreate(eventArg, out view) && m_OrderBookViews.TryAdd(eventArg.Instrument, view))
{
this.SuspendLayout();
Size defaultSize = new Size(view.Size.Width, view.Size.Height);
this.ClientSize = new Size(defaultSize.Width * nColumns, defaultSize.Height);
// Place on screen
int nY = (int)Math.Ceiling((1.0 * m_OrderBookViews.Count) / nColumns) - 1;
int nX = (m_OrderBookViews.Count - 1) % nColumns;
view.Location = new Point(nX * defaultSize.Width, nY * defaultSize.Height);
this.Controls.Add(view);
this.ResumeLayout(true);
}
}// CreateOrderBookView()
protected void OnOrderBook(object sender, OrderBookEventArgs e, CurrencyName instrument)
{
e.Instrument1 = instrument;
_orderBookHandler(((IExchange)sender).GetExchangeName(), e);
}
public void SubscribeOrderBook(OrderBookEventArgs orderBookEventArgs)
{
throw new NotImplementedException();
}
} //HubEventHandler()
//
//
//
// *****************************************************
// **** Process Request() ****
// *****************************************************
private void ProcessRequest(OrderHubRequest eventArg)
{
Log.NewEntry(LogLevel.Minor, "ProcessRequest: {0}", eventArg);
switch (eventArg.Request)
{
case OrderHubRequest.RequestType.RequestConnect:
// We automatically connect to the TT Api once we get the call back from it.
break;
case OrderHubRequest.RequestType.RequestCreateFillBook:
if (eventArg.Data[0] is TT.InstrumentKey)
{
TT.InstrumentKey ttKey = (TT.InstrumentKey)eventArg.Data[0];
InstrumentName name;
if (m_TTKey2Name.TryGetValue(ttKey, out name) && m_Books.ContainsKey(name))
{
Log.NewEntry(LogLevel.Minor, "ProcessRequest: Already have book for {1}. Ignoring {0}.", eventArg, name);
}
else
{
OrderBookTT book;
if (TryCreateNewBook(ttKey, out book))
{
Log.NewEntry(LogLevel.Minor, "ProcessRequest: Create book succeeded {0}.", book);
OrderBookEventArgs outgoingEventArg = new OrderBookEventArgs(this, book.m_InstrumentName, OrderBookEventArgs.EventTypes.CreatedBook);
OnBookCreated(outgoingEventArg); // TODO: Load additional information needed for new book creation.
// Push out waiting events.
ConcurrentQueue <EventArgs> waitingTTOrders;
while (m_TTEventsToProcess.TryRemove(ttKey, out waitingTTOrders)) // this should only execute once, but if new orders are added concurrently could execute more!
{
EventArgs eventArg1;
while (waitingTTOrders.Count > 0)
{
if (waitingTTOrders.TryDequeue(out eventArg1))
{
this.HubEventEnqueue(eventArg1);
}
else
{
break;
}
}
}
}
else
{
Log.NewEntry(LogLevel.Minor, "ProcessRequest: Create book failed. Will try again.");
m_WaitingRequests.Enqueue(eventArg); // Store this request
}
}
}
break;
case OrderHubRequest.RequestType.RequestShutdown:
if (m_OrderListener != null)
{
m_OrderListener.Dispose();
m_OrderListener = null;
}
base.Stop();
break;
default:
break;
} // switch request
} //ProcessRequest()
