/// <summary> /// Dispose of all the TT API objects and shutdown the TT API /// </summary> public void shutdownTTAPI() { if (!m_shutdownInProcess) { // Dispose of all request objects if (m_customerDefaultsSubscription != null) { m_customerDefaultsSubscription.CustomerDefaultsChanged -= m_customerDefaultsSubscription_CustomerDefaultsChanged; m_customerDefaultsSubscription.Dispose(); m_customerDefaultsSubscription = null; } if (m_instrumentTradeSubscription != null) { m_instrumentTradeSubscription.OrderAdded -= m_instrumentTradeSubscription_OrderAdded; m_instrumentTradeSubscription.OrderRejected -= m_instrumentTradeSubscription_OrderRejected; m_instrumentTradeSubscription.Dispose(); m_instrumentTradeSubscription = null; } if (m_priceSubscription != null) { m_priceSubscription.FieldsUpdated -= m_priceSubscription_FieldsUpdated; m_priceSubscription.Dispose(); m_priceSubscription = null; } TTAPI.ShutdownCompleted += new EventHandler(TTAPI_ShutdownCompleted); TTAPI.Shutdown(); } // only run shutdown once m_shutdownInProcess = true; }
/// <summary> /// Event notification for instrument lookup /// </summary> void m_req_Update(object sender, InstrumentLookupSubscriptionEventArgs e) { if (e.Instrument != null && e.Error == null) { // Instrument was found Console.WriteLine("Found: {0}", e.Instrument.Name); // Subscribe for Inside Market Data m_ps = new PriceSubscription(e.Instrument, Dispatcher.Current); m_ps.Settings = new PriceSubscriptionSettings(PriceSubscriptionType.InsideMarket); m_ps.FieldsUpdated += new FieldsUpdatedEventHandler(m_ps_FieldsUpdated); m_ps.Start(); // Create a TradeSubscription to listen for order / fill events only for orders submitted through it m_ts = new InstrumentTradeSubscription(m_apiInstance.Session, Dispatcher.Current, e.Instrument, true, true, false, false); m_ts.OrderUpdated += new EventHandler <OrderUpdatedEventArgs>(m_ts_OrderUpdated); m_ts.OrderAdded += new EventHandler <OrderAddedEventArgs>(m_ts_OrderAdded); m_ts.OrderDeleted += new EventHandler <OrderDeletedEventArgs>(m_ts_OrderDeleted); m_ts.OrderFilled += new EventHandler <OrderFilledEventArgs>(m_ts_OrderFilled); m_ts.OrderRejected += new EventHandler <OrderRejectedEventArgs>(m_ts_OrderRejected); m_ts.Start(); } else if (e.IsFinal) { // Instrument was not found and TT API has given up looking for it Console.WriteLine("Cannot find instrument: {0}", e.Error.Message); Dispose(); } }
/// <summary> /// Create subscriptions and update the GUI. /// </summary> /// <param name="instrument">Instrument to create subscriptions with.</param> private void instrumentFound(Instrument instrument) { txtExchange.Text = instrument.Key.MarketKey.Name; txtProduct.Text = instrument.Key.ProductKey.Name; txtProductType.Text = instrument.Key.ProductKey.Type.Name; txtContract.Text = instrument.Name; m_priceSubscription = new PriceSubscription(instrument, Dispatcher.Current); m_priceSubscription.FieldsUpdated += new FieldsUpdatedEventHandler(m_priceSubscription_FieldsUpdated); m_priceSubscription.Start(); m_instrumentTradeSubscription = new InstrumentTradeSubscription(m_TTAPI.Session, Dispatcher.Current, instrument); m_instrumentTradeSubscription.OrderAdded += new EventHandler <OrderAddedEventArgs>(m_instrumentTradeSubscription_OrderAdded); m_instrumentTradeSubscription.OrderRejected += new EventHandler <OrderRejectedEventArgs>(m_instrumentTradeSubscription_OrderRejected); m_instrumentTradeSubscription.Start(); populateOrderFeedDropDown(instrument); // Enable the user interface items. txtQuantity.Enabled = true; cboOrderType.Enabled = true; comboBoxOrderFeed.Enabled = true; cboCustomer.Enabled = true; btnBuy.Enabled = true; btnSell.Enabled = true; }
public static bool ChangeLimitOrder(string orderKey, TradingTechnologies.TTAPI.Instrument instrument, Subscription ttapisubs, double price, Logger logger) { InstrumentTradeSubscription TS = ttapisubs.TsDictionary[instrument.Key]; bool Status = true; OrderProfileBase Op = TS.Orders[orderKey].GetOrderProfile(); Price LimitPrice = Price.FromDouble(instrument.InstrumentDetails, price); if (Op.LimitPrice != LimitPrice) { Op.LimitPrice = LimitPrice; Op.Action = OrderAction.Change; if (!TS.SendOrder(Op)) { logger.Log("Send change order failed. {0}" + Op.RoutingStatus.Message); Status = false; } else { logger.Log("Send change order succeeded."); } } return(Status); }
public void startTradeSubscriptions(object sender, InstrumentLookupSubscriptionEventArgs e) { if (e.Instrument != null && e.Error == null) { // Create a TradeSubscription to listen for order / fill events only for orders submitted through it ts = new InstrumentTradeSubscription(m_apiInstance.Session, Dispatcher.Current, e.Instrument, true, true, false, false); ts.OrderUpdated += new EventHandler <OrderUpdatedEventArgs>(m_ts_OrderUpdated); ts.OrderAdded += new EventHandler <OrderAddedEventArgs>(m_ts_OrderAdded); ts.OrderDeleted += new EventHandler <OrderDeletedEventArgs>(m_ts_OrderDeleted); if (orderFilledEventHandler != null) { ts.OrderFilled += new EventHandler <OrderFilledEventArgs>(orderFilledEventHandler); } ts.OrderRejected += new EventHandler <OrderRejectedEventArgs>(m_ts_OrderRejected); TsDictionary.Add(e.Instrument.Key, ts); ts.Start(); } else if (e.IsFinal) { // Instrument was not found and TT API has given up looking for it Console.WriteLine("Cannot find instrument: {0}", e.Error.Message); Dispose(); } }
public static string SendLimitOrder(TradingTechnologies.TTAPI.Instrument instrument, TradingTechnologies.TTAPI.Price price, int qty, Subscription ttapisubs, string orderTag = "") { BuySell Direction = BuySell.Buy; string AccountName = "H1KOC"; if (qty < 0) { Direction = BuySell.Sell; qty = -qty; } string tickerDB = TA.TickerConverters.ConvertFromTTAPIFields2DB(instrument.Product.ToString(), instrument.Name.ToString()); string[] TickerList = tickerDB.Split('-'); string TickerHead = ContractUtilities.ContractMetaInfo.GetContractSpecs(TickerList[0]).tickerHead; string ExchangeName = ContractUtilities.ContractMetaInfo.GetExchange4Tickerhead(TickerHead); AccountType AccType = AccountType.P2; OrderProfile op = new OrderProfile(instrument.GetValidOrderFeeds()[0], instrument); op.BuySell = Direction; op.AccountName = AccountName; if (ExchangeName == "ICE") { AccType = AccountType.G2; op.GiveUp = "5283"; } op.AccountType = AccType; op.OrderQuantity = Quantity.FromInt(instrument, qty); op.OrderType = OrderType.Limit; if (orderTag.Count() > 0) { op.OrderTag = orderTag; } op.LimitPrice = price; InstrumentTradeSubscription TS = ttapisubs.TsDictionary[instrument.Key]; if (!TS.SendOrder(op)) { Console.WriteLine("Send new order failed. {0}", op.RoutingStatus.Message); ttapisubs.Dispose(); } else { Console.WriteLine("Send new order succeeded."); } return(op.SiteOrderKey); }
/// <summary> /// Event notification for instrument lookup /// </summary> public void req_Update(object sender, InstrumentLookupSubscriptionEventArgs e) { if (e.Instrument != null && e.Error == null) { cout("Subscribed to Instrument: {0}", e.Instrument.Key); _instruments[GetIid(e.Instrument)].FoundInstrument(e.Instrument); // Market Depth subscription (or just Inside Market if you change the PriceSubscriptionSettings) var prcSub = new PriceSubscription(e.Instrument, Dispatcher.Current); //psSub.Settings = new PriceSubscriptionSettings(PriceSubscriptionType.InsideMarket); prcSub.Settings = new PriceSubscriptionSettings(PriceSubscriptionType.MarketDepth); prcSub.FieldsUpdated += new FieldsUpdatedEventHandler(m_prc_FieldsUpdated); m_lprc.Add(prcSub); prcSub.Start(); // Time & Sales subscription var tsSub = new TimeAndSalesSubscription(e.Instrument, Dispatcher.Current); tsSub.Update += new EventHandler <TimeAndSalesEventArgs>(tsSub_Update); m_lts.Add(tsSub); tsSub.Start(); // Fills subscription var filSub = new FillsSubscription(m_TTAPI.Session, Dispatcher.Current); filSub.FillAdded += new EventHandler <FillAddedEventArgs>(m_fil_FillAdded); filSub.FillAmended += new EventHandler <FillAmendedEventArgs>(m_fil_FillAmended); filSub.FillBookDownload += new EventHandler <FillBookDownloadEventArgs>(m_fil_FillBookDownload); filSub.FillDeleted += new EventHandler <FillDeletedEventArgs>(m_fil_FillDeleted); filSub.FillListEnd += new EventHandler <FillListEventArgs>(m_fil_FillListEnd); filSub.FillListStart += new EventHandler <FillListEventArgs>(m_fil_FillListStart); m_lfil.Add(filSub); filSub.Start(); // Trade Subscription (to listen for order / fill events only for orders submitted through it) var trdSub = new InstrumentTradeSubscription(m_TTAPI.Session, Dispatcher.Current, e.Instrument, true, true, false, false); trdSub.OrderUpdated += new EventHandler <OrderUpdatedEventArgs>(m_trd_OrderUpdated); trdSub.OrderAdded += new EventHandler <OrderAddedEventArgs>(m_trd_OrderAdded); trdSub.OrderDeleted += new EventHandler <OrderDeletedEventArgs>(m_trd_OrderDeleted); trdSub.OrderFilled += new EventHandler <OrderFilledEventArgs>(m_trd_OrderFilled); trdSub.OrderRejected += new EventHandler <OrderRejectedEventArgs>(m_trd_OrderRejected); m_dtrd[e.Instrument.Key] = trdSub; trdSub.Start(); } else if (e.IsFinal) { // Instrument was not found and TT API has given up looking for it cout("Cannot find instrument, and giving up: {0}", e.Error.Message); Dispose(); } else { cout("Cannot find instrument: {0}", e.Error.Message); } }
private void CreateInstrumentTradeSubscription(Instrument instrument) { if (m_instrumentTradeSubscription != null) { m_instrumentTradeSubscription.Dispose(); m_instrumentTradeSubscription = null; } m_instrumentTradeSubscription = new InstrumentTradeSubscription(m_TTAPI.Session, Dispatcher.Current, instrument); m_instrumentTradeSubscription.OrderAdded += new EventHandler <OrderAddedEventArgs>(instrumentTradeSubscription_OrderAdded); m_instrumentTradeSubscription.OrderDeleted += new EventHandler <OrderDeletedEventArgs>(instrumentTradeSubscription_OrderDeleted); }
void req_Update(object sender, InstrumentLookupSubscriptionEventArgs e) { Console.WriteLine("req_Update"); if (e.Instrument != null && e.Error == null) { tslblInfo.Text = "SUBSCRIBED: " + e.Instrument.Name; Message("SUBSCRIBED: " + e.Instrument.Name); // if this instrument is one of our managed hedges, then add it // to the managed hedge dictionary foreach (InstrumentInfo info in managedHedgeList) { if (info.ProductKey == e.Instrument.Product.Key && e.Instrument.Name.Contains(info.Contract)) // && info.Contract.Equals(e.Instrument.Name)) { info.Instrument = e.Instrument; info.InstrumentKey = e.Instrument.Key; managedHedges.Add(e.Instrument.Key, info); } } // iterate order feeds enabled for each instrument foreach (OrderFeed oFeed in e.Instrument.GetValidOrderFeeds()) { if (oFeed.IsTradingEnabled) { Console.WriteLine("Order feed {0} is enabled for trading", oFeed.ToString()); } else { Console.WriteLine("Order feed {0} is NOT enabled for trading", oFeed.ToString()); } } // successfully subscribed to an instrument so request prices PriceSubscription priceSub = new PriceSubscription(e.Instrument, Dispatcher.Current); priceSub.Settings = new PriceSubscriptionSettings(PriceSubscriptionType.InsideMarket); priceSub.FieldsUpdated += new FieldsUpdatedEventHandler(priceSub_FieldsUpdated); priceSub.Start(); InstrumentTradeSubscription its = new InstrumentTradeSubscription(apiInstance.Session, Dispatcher.Current, e.Instrument); its.Start(); } else if (e.IsFinal) { // Instrument was not found and TTAPI has given up looking for it tslblInfo.Text = "ERROR: " + e.Error.Message; } }
/// <summary> /// Dispose of all the TT API objects and shutdown the TT API /// </summary> public void shutdownTTAPI() { if (!m_shutdownInProcess) { // Dispose of all request objects if (m_instrumentTradeSubscription != null) { m_instrumentTradeSubscription.ProfitLossChanged -= instrumentTradeSubscription_ProfitLossChanged; m_instrumentTradeSubscription.Dispose(); m_instrumentTradeSubscription = null; } TTAPI.ShutdownCompleted += new EventHandler(TTAPI_ShutdownCompleted); TTAPI.Shutdown(); } // only run shutdown once m_shutdownInProcess = true; }
/// <summary> /// Instrument request completed event. /// </summary> void instrRequest_Completed(object sender, InstrumentLookupSubscriptionEventArgs e) { if (e.IsFinal && e.Instrument != null) { try { UpdateStatusBar("Instrument Found."); Console.WriteLine(String.Format("TT API FindInstrument {0}", e.Instrument.Name)); // Grab the contract specifications and output to the user this.txtExchange.Text = e.Instrument.Product.Market.Name; this.txtProduct.Text = e.Instrument.Product.Name; this.txtProductType.Text = e.Instrument.Product.Type.ToString(); this.txtContract.Text = e.Instrument.GetFormattedName(InstrumentNameFormat.User); if (m_instrumentTradeSubscription != null) { m_instrumentTradeSubscription.Dispose(); m_instrumentTradeSubscription = null; } // The use of the InstrumentTradeSubscription will filter for a specific instrument m_instrumentTradeSubscription = new InstrumentTradeSubscription(m_TTAPI.Session, Dispatcher.Current, e.Instrument); m_instrumentTradeSubscription.EnablePNL = true; m_instrumentTradeSubscription.ProfitLossChanged += new EventHandler <ProfitLossChangedEventArgs>(instrumentTradeSubscription_ProfitLossChanged); m_instrumentTradeSubscription.Start(); } catch (Exception err) { Console.WriteLine(String.Format("TT API FindInstrument Exception: {0}", err.Message)); } } else if (e.IsFinal) { Console.WriteLine(String.Format("TT API FindInstrument Instrument Not Found: {0}", e.Error)); } else { Console.WriteLine(String.Format("TT API FindInstrument Instrument Not Found: (Still Searching) {0}", e.Error)); } }
public static bool CancelLimitOrder(string orderKey, TradingTechnologies.TTAPI.Instrument instrument, Subscription ttapisubs, Logger logger) { InstrumentTradeSubscription TS = ttapisubs.TsDictionary[instrument.Key]; bool Status = true; OrderProfileBase Op = TS.Orders[orderKey].GetOrderProfile(); Op.Action = OrderAction.Delete; if (!TS.SendOrder(Op)) { logger.Log("Cancal order failed. {0}" + Op.RoutingStatus.Message); Status = false; } else { logger.Log("Cancel order succeeded."); } return(Status); }
void ils_Update(object sender, InstrumentLookupSubscriptionEventArgs e) { Console.WriteLine("ils_Update"); if (e.Instrument != null && e.Error == null) { Message("SUBSCRIBED: " + e.Instrument.Name); // iterate order feeds enabled for each instrument foreach (OrderFeed oFeed in e.Instrument.GetValidOrderFeeds()) { if (oFeed.IsTradingEnabled) { Console.WriteLine("Order feed {0} is enabled for trading", oFeed.ToString()); } else { Console.WriteLine("Order feed {0} is NOT enabled for trading", oFeed.ToString()); } } // successfully subscribed to an instrument so request prices PriceSubscription priceSub = new PriceSubscription(e.Instrument, Dispatcher.Current); priceSub.Settings = new PriceSubscriptionSettings(PriceSubscriptionType.InsideMarket); priceSub.FieldsUpdated += new FieldsUpdatedEventHandler(priceSub_FieldsUpdated); priceSub.Start(); InstrumentTradeSubscription its = new InstrumentTradeSubscription(apiInstance.Session, Dispatcher.Current, e.Instrument); its.EnablePNL = true; its.ProfitLossChanged += new EventHandler <ProfitLossChangedEventArgs>(its_ProfitLossChanged); its.Start(); instruments[e.Instrument.Key].Instrument = e.Instrument; instruments[e.Instrument.Key].TradeSubscription = its; } else if (e.IsFinal) { // Instrument was not found and TTAPI has given up looking for it ErrorMessage(e.Error.Message); } }
TTInstrument processInstrumentFound(Instrument instrument) { Dispatcher dispatcher = Dispatcher.Current; //Dispatcher dispatcher = _dispatcher; PriceSubscription priceSub = new PriceSubscription(instrument, dispatcher); if (SubscribeMarketDepth == true) { priceSub.Settings = new PriceSubscriptionSettings(PriceSubscriptionType.MarketDepth); } else { priceSub.Settings = new PriceSubscriptionSettings(PriceSubscriptionType.InsideMarket); } priceSub.FieldsUpdated += new FieldsUpdatedEventHandler(priceSub_FieldsUpdated); priceSub.Start(); InstrumentTradeSubscription its = new InstrumentTradeSubscription(_apiSession, dispatcher, instrument); its.EnablePNL = true; its.ProfitLossChanged += new EventHandler <ProfitLossChangedEventArgs>(its_ProfitLossChanged); its.Start(); if (SubscribeTimeAndSales == true) { TimeAndSalesSubscription tsSub = new TimeAndSalesSubscription(instrument, dispatcher); tsSub.Update += new EventHandler <TimeAndSalesEventArgs>(tsSub_Update); tsSub.Start(); } TTInstrument tti = NewTTInstrument(instrument); tti.TradeSubscription = its; its.Tag = tti; tti.OrderRoute = OrderRoute.GetOrderRoute(tti, instrument.Product.Market.Name); return(tti); }
/// <summary> /// Shuts down the TT API /// </summary> public void Dispose() { lock (m_lock) { if (!m_disposed) { // Unattached callbacks and dispose of all subscriptions if (m_req != null) { m_req.Update -= m_req_Update; m_req.Dispose(); m_req = null; } if (m_ps != null) { m_ps.FieldsUpdated -= m_ps_FieldsUpdated; m_ps.Dispose(); m_ps = null; } if (m_ts != null) { m_ts.OrderAdded -= m_ts_OrderAdded; m_ts.OrderDeleted -= m_ts_OrderDeleted; m_ts.OrderFilled -= m_ts_OrderFilled; m_ts.OrderRejected -= m_ts_OrderRejected; m_ts.OrderUpdated -= m_ts_OrderUpdated; m_ts.Dispose(); m_ts = null; } // Begin shutdown the TT API TTAPI.ShutdownCompleted += new EventHandler(TTAPI_ShutdownCompleted); TTAPI.Shutdown(); m_disposed = true; } } }
public void Dispose() { lock (m_Lock) { if (!m_isDisposed) { // Unattached callbacks and dispose of all subscriptions if (m_instrLookupRequest != null) { m_instrLookupRequest.OnData -= m_instrLookupRequest_OnData; m_instrLookupRequest.Dispose(); m_instrLookupRequest = null; } if (m_priceSubscription != null) { m_priceSubscription.FieldsUpdated -= m_priceSubscription_FieldsUpdated; m_priceSubscription.Dispose(); m_priceSubscription = null; } if (m_instrumentTradeSubscription != null) { m_instrumentTradeSubscription.OrderUpdated -= m_instrumentTradeSubscription_OrderUpdated; m_instrumentTradeSubscription.OrderAdded -= m_instrumentTradeSubscription_OrderAdded; m_instrumentTradeSubscription.OrderDeleted -= m_instrumentTradeSubscription_OrderDeleted; m_instrumentTradeSubscription.OrderFilled -= m_instrumentTradeSubscription_OrderFilled; m_instrumentTradeSubscription.OrderRejected -= m_instrumentTradeSubscription_OrderRejected; m_instrumentTradeSubscription.Dispose(); m_instrumentTradeSubscription = null; } m_isDisposed = true; } TTAPI.Shutdown(); } }
//////////////////////////////////////////////////////////////////////////////////////////////////// /// <summary> Event notification for instrument lookup. </summary> /// <param name="sender"> Source of the event. </param> /// <param name="e"> Instrument lookup subscription event information. </param> //////////////////////////////////////////////////////////////////////////////////////////////////// void m_instrLookupRequest_OnData(object sender, InstrumentLookupEventArgs e) { if (e.Event == ProductDataEvent.Found) { // Instrument was found Instrument instrument = e.InstrumentLookup.Instrument; Console.WriteLine("Found: {0}", instrument); // Subscribe for market Data m_priceSubscription = new PriceSubscription(instrument, tt_net_sdk.Dispatcher.Current); m_priceSubscription.Settings = new PriceSubscriptionSettings(PriceSubscriptionType.MarketDepth); m_priceSubscription.FieldsUpdated += m_priceSubscription_FieldsUpdated; m_priceSubscription.Start(); // Create a TradeSubscription to listen for order / fill events only for orders submitted through it m_instrumentTradeSubscription = new InstrumentTradeSubscription(tt_net_sdk.Dispatcher.Current, instrument); m_instrumentTradeSubscription.OrderUpdated += new EventHandler <OrderUpdatedEventArgs>(m_instrumentTradeSubscription_OrderUpdated); m_instrumentTradeSubscription.OrderAdded += new EventHandler <OrderAddedEventArgs>(m_instrumentTradeSubscription_OrderAdded); m_instrumentTradeSubscription.OrderDeleted += new EventHandler <OrderDeletedEventArgs>(m_instrumentTradeSubscription_OrderDeleted); m_instrumentTradeSubscription.OrderFilled += new EventHandler <OrderFilledEventArgs>(m_instrumentTradeSubscription_OrderFilled); m_instrumentTradeSubscription.OrderRejected += new EventHandler <OrderRejectedEventArgs>(m_instrumentTradeSubscription_OrderRejected); m_instrumentTradeSubscription.OrderBookDownload += new EventHandler <OrderBookDownloadEventArgs>(m_instrumentTradeSubscription_OrderBookDownload); m_instrumentTradeSubscription.Start(); } else if (e.Event == ProductDataEvent.NotAllowed) { Console.WriteLine("Not Allowed : Please check your Token access"); } else { // Instrument was not found and TT API has given up looking for it Console.WriteLine("Cannot find instrument: {0}", e.Message); Dispose(); } }
/// <summary> /// Instrument request completed event. /// </summary> void instrRequest_Completed(object sender, TT.InstrumentLookupSubscriptionEventArgs e) { if (e.IsFinal && e.Instrument != null) { try { cout("TT API FindInstrument {0}", e.Instrument.Name); TTInstrument ttinstr = _instruments.Values.First(tti => tti.InstrumentKey == e.Instrument.Key); ttinstr.FoundInstrument(e.Instrument); // subscribe for price updates m_priceSubscription = new TT.PriceSubscription(e.Instrument, TT.Dispatcher.Current); m_priceSubscription.Settings = new TT.PriceSubscriptionSettings(TT.PriceSubscriptionType.InsideMarket); m_priceSubscription.FieldsUpdated += new TT.FieldsUpdatedEventHandler(priceSubscription_FieldsUpdated); m_priceSubscription.Start(); // subscribe for trade updates m_instrumentTradeSubscription = new InstrumentTradeSubscription(m_TTAPI.Session, TT.Dispatcher.Current, e.Instrument); m_instrumentTradeSubscription.OrderAdded += new EventHandler <TT.OrderAddedEventArgs>(m_instrumentTradeSubscription_OrderAdded); m_instrumentTradeSubscription.OrderRejected += new EventHandler <TT.OrderRejectedEventArgs>(m_instrumentTradeSubscription_OrderRejected); m_instrumentTradeSubscription.Start(); } catch (Exception err) { ErrorMessage("TT API FindInstrument Exception: {0}", err.Message); } } else if (e.IsFinal) { cout("TT API FindInstrument Instrument Not Found: {0}", e.Error); } else { cout("TT API FindInstrument Instrument Not Found: (Still Searching) {0}", e.Error); } }
void GetBidAsk(object sender, FieldsUpdatedEventArgs e) { if (e.Error == null) { if ((string.IsNullOrEmpty(e.Fields.GetDirectBidPriceField().FormattedValue)) || (string.IsNullOrEmpty(e.Fields.GetDirectAskPriceField().FormattedValue))) { return; } string InstrumentName = e.Fields.Instrument.Name.ToString(); TickerDB = TA.TickerConverters.ConvertFromTTAPIFields2DB(e.Fields.Instrument.Product.ToString(), e.Fields.Instrument.Name.ToString()); string TickerHead = TA.TickerheadConverters.ConvertFromTT2DB(e.Fields.Instrument.Product.ToString()); UpdatePriceData(ticker: TickerDB, tickerHead: TickerHead, e: e); TA.ttapiTicker TTAPITicker = TA.TickerConverters.ConvertFromDbTicker2ttapiTicker(dbTicker: TickerDB, productType: e.Fields.Instrument.Product.Type.ToString()); InstrumentKey IKey = new InstrumentKey(new ProductKey(e.Fields.Instrument.Product.Market.Key, e.Fields.Instrument.Product.Type, e.Fields.Instrument.Product.Name), TTAPITicker.SeriesKey); Ts = TTAPISubs.TsDictionary[e.Fields.Instrument.Key]; if (IlsDictionary.ContainsKey(IKey)) { for (int i = 0; i < ilsUpdateList.Count; i++) { IlsDictionary[IKey].Update -= ilsUpdateList[i]; } IlsDictionary[IKey].Dispose(); IlsDictionary[IKey] = null; IlsDictionary.Remove(IKey); TTAPISubs.IlsDictionary = IlsDictionary; } if ((IlsDictionary.Count == 0) & (!PricesReceivedQ)) { PricesReceivedQ = true; HedgeStrategies.HedgeStrategiesAgainstDelta(conn: conn, priceTable: PriceData); DataTable StdMoves = CalculateStdMoves(priceData: PriceData); DataTable HedgeTable = GenerateHedgeTable(conn: conn); NetHedgeTable = CalculateUrgency(hedgeTable: HedgeTable); //NetHedgeTable = NetHedgeTable.Select("IsSpreadQ=true").CopyToDataTable(); List <string> TickerHeads2Report = DataAnalysis.DataTableFunctions.GetColumnAsList <string>(dataTableInput: StdMoves, columnName: "TickerHead", uniqueQ: true); foreach (string TickerHead2Report in TickerHeads2Report) { DeltaLogger.Log(new String('-', 20)); DataRow[] SelectedRows = StdMoves.Select("TickerHead='" + TickerHead2Report + "'"); foreach (DataRow Row in SelectedRows) { DeltaLogger.Log(Row.Field <string>("Ticker") + " std change: " + Row.Field <double>("StdChange")); } DataRow[] SelectedHedgeRows = NetHedgeTable.Select("TickerHead='" + TickerHead2Report + "'"); foreach (DataRow Row in SelectedHedgeRows) { DeltaLogger.Log(Row.Field <int>("Hedge") + " " + Row.Field <string>("Ticker") + " with urgency " + Row.Field <decimal>("Urgency")); } } Console.Write("Do you agree? (Y/N): "); Decision = Console.ReadLine(); Decision = Decision.ToUpper(); DataColumn WorkingOrdersColumn = new DataColumn("WorkingOrders", typeof(int)); WorkingOrdersColumn.DefaultValue = 0; NetHedgeTable.Columns.Add(WorkingOrdersColumn); NetHedgeTickerList = DataAnalysis.DataTableFunctions.GetColumnAsList <string>(dataTableInput: NetHedgeTable, columnName: "Ticker"); } if ((PricesReceivedQ) && (Decision == "Y")) { int RowIndex = NetHedgeTickerList.IndexOf(TickerDB); if ((RowIndex < 0) || (NetHedgeTable.Rows[RowIndex].Field <int>("WorkingOrders") != 0)) { return; } Price BidPrice = e.Fields.GetDirectBidPriceField().Value; Price AskPrice = e.Fields.GetDirectAskPriceField().Value; Price MidPrice = (AskPrice + BidPrice) / 2; Price TradePrice; NetHedgeTable.Rows[RowIndex]["WorkingOrders"] = NetHedgeTable.Rows[RowIndex].Field <int>("Hedge"); if (NetHedgeTable.Rows[RowIndex].Field <int>("Hedge") > 0) { if (NetHedgeTable.Rows[RowIndex].Field <decimal>("Urgency") > 5) { TradePrice = MidPrice.Round(Rounding.Up); } else { TradePrice = BidPrice; } } else if (NetHedgeTable.Rows[RowIndex].Field <int>("Hedge") < 0) { if (NetHedgeTable.Rows[RowIndex].Field <decimal>("Urgency") > 5) { TradePrice = MidPrice.Round(Rounding.Down); } else { TradePrice = AskPrice; } } else { return; } DeltaLogger.Log(NetHedgeTable.Rows[RowIndex].Field <int>("Hedge") + " " + TickerDB + " for " + TradePrice + ", Bid: " + e.Fields.GetDirectBidPriceField().FormattedValue + ", Ask: " + e.Fields.GetDirectAskPriceField().FormattedValue); ttapiUtils.Trade.SendLimitOrder(instrument: e.Fields.Instrument, price: TradePrice, qty: NetHedgeTable.Rows[RowIndex].Field <int>("Hedge"), ttapisubs: TTAPISubs, orderTag: "DeltaHedge"); } } else { if (e.Error.IsRecoverableError == false) { Console.WriteLine("Unrecoverable price subscription error: {0}", e.Error.Message); //Dispose(); } } }
/// <summary> /// Instrument request completed event. /// </summary> void instrRequest_Completed(object sender, InstrumentLookupSubscriptionEventArgs e) { if (e.IsFinal && e.Instrument != null) { try { UpdateStatusBar("Instrument Found."); Console.WriteLine(String.Format("TT API FindInstrument {0}", e.Instrument.Name)); // Grab the contract specifications and output to the user this.txtExchange.Text = e.Instrument.Product.Market.Name; this.txtProduct.Text = e.Instrument.Product.Name; this.txtProductType.Text = e.Instrument.Product.Type.ToString(); this.txtContract.Text = e.Instrument.GetFormattedName(InstrumentNameFormat.User); if (m_instrumentTradeSubscription != null) { m_instrumentTradeSubscription.Dispose(); m_instrumentTradeSubscription = null; } // The use of the InstrumentTradeSubscription will filter for a specific instrument m_instrumentTradeSubscription = new InstrumentTradeSubscription(m_TTAPI.Session, Dispatcher.Current, e.Instrument); m_instrumentTradeSubscription.EnablePNL = true; m_instrumentTradeSubscription.ProfitLossChanged += new EventHandler<ProfitLossChangedEventArgs>(instrumentTradeSubscription_ProfitLossChanged); m_instrumentTradeSubscription.Start(); } catch (Exception err) { Console.WriteLine(String.Format("TT API FindInstrument Exception: {0}", err.Message)); } } else if (e.IsFinal) { Console.WriteLine(String.Format("TT API FindInstrument Instrument Not Found: {0}", e.Error)); } else { Console.WriteLine(String.Format("TT API FindInstrument Instrument Not Found: (Still Searching) {0}", e.Error)); } }
/// <summary> /// Event notification for price update /// </summary> void BreakoutAlgo(object sender, FieldsUpdatedEventArgs e) { if (e.Error == null) { dateTimeNow = DateTime.Now; if ((dateTimeNow-DateTimePastPnlDisplay).Minutes>10) { DisplayPnl(); DateTimePastPnlDisplay = dateTimeNow; } if (string.IsNullOrEmpty(e.Fields.GetDirectBidPriceField().FormattedValue)) { return; } else { bidPrice = Convert.ToDouble(e.Fields.GetDirectBidPriceField().FormattedValue); } if (string.IsNullOrEmpty(e.Fields.GetDirectAskPriceField().FormattedValue)) { return; } else { askPrice = Convert.ToDouble(e.Fields.GetDirectAskPriceField().FormattedValue); } midPrice = (bidPrice + askPrice) / 2; spreadPrice = askPrice - bidPrice; tickerDB = TA.TickerConverters.ConvertFromTTAPIFields2DB(e.Fields.Instrument.Product.ToString(), e.Fields.Instrument.Name.ToString()); string TickerHead = ContractUtilities.ContractMetaInfo.GetContractSpecs(tickerDB).tickerHead; string ExchangeName = ContractUtilities.ContractMetaInfo.GetExchange4Tickerhead(TickerHead); FilledPosition = BreakoutPosition.GetFilledPosition4Ticker(tickerDB); WorkingPosition = BreakoutPosition.GetWorkingPosition4Ticker(tickerDB); TotalPosition = FilledPosition + WorkingPosition; Std4Ticker = StdDict[tickerDB]; Qty4Ticker = QtyDict[tickerDB]; TotalOrders = BreakoutPosition.PositionWithAllOrders.Select("Qty<>0").Length; int tickerIndex = Enumerable.Range(0, dbTickerList.Count).Where(i => dbTickerList[i] == tickerDB).ToList()[0]; ts = ttapiSubs.TsDictionary[e.Fields.Instrument.Key]; if ((midPrice < rangeMinList[tickerIndex]) && (FilledPosition == 0) && (WorkingPosition==0) && (dateTimeNow < LastTradeEntryTime)) { if (Std4Ticker>StdPerBet) { BreakoutLogger.Log(tickerDB + " has std " + Std4Ticker + " too large for current risk limits! "); return; } PortfolioVarChange = Risk.PorfolioRisk.GetChangeInRiskAfterTickerInclusion(BreakoutPosition.PositionWithAllOrders, CovMatrix, tickerDB, -Qty4Ticker); PortfolioStdAfter = Math.Sqrt(Math.Pow(PortfolioStd, 2) + PortfolioVarChange); if (double.IsNaN(PortfolioStdAfter)) { BreakoutLogger.Log("After trading " + tickerDB + " portfolio std would be: " + PortfolioStdAfter); BreakoutLogger.Log("PortfolioStd: " + PortfolioStd); BreakoutLogger.Log("PortfolioVarChange: " + PortfolioVarChange); return; } if (PortfolioStdAfter > PortfolioStdLimit) { BreakoutLogger.Log("After trading " + tickerDB + " portfolio std would be: " + PortfolioStdAfter + " too large!"); return; } else { BreakoutLogger.Log(tickerDB + " trade satisfies risk limit with target portfolio risk: " + PortfolioStdAfter); } BreakoutLogger.Log("Bearish Breakout in " + tickerDB); BreakoutLogger.Log("Range Min: " + rangeMinList[tickerIndex]); BreakoutLogger.Log("Current Price: " + midPrice); BreakoutLogger.Log("Std 4 Ticker: " + Std4Ticker); if (TotalOrders>=MaxOrdersSent) { BreakoutLogger.Log("Total orders sent : " + TotalOrders + " is not smaller than " +MaxOrdersSent); return; } if (LiveTradingQ) { ttapiUtils.Trade.SendLimitOrder(e.Fields.Instrument, e.Fields.GetBestAskPriceField().Value, -Qty4Ticker, ttapiSubs); BreakoutPosition.OrderSend(tickerDB, -Qty4Ticker); } else { BreakoutPosition.OrderSend(tickerDB, -Qty4Ticker); BreakoutPosition.OrderFill(tickerDB, -Qty4Ticker); } PortfolioStd = Risk.PorfolioRisk.GetPortfolioRiskFromCovMatrix(BreakoutPosition.PositionWithAllOrders, CovMatrix); BreakoutLogger.Log("Portfolio Std After Fill: " + PortfolioStd); } else if ((midPrice > rangeMaxList[tickerIndex]) && (FilledPosition == 0) && (WorkingPosition == 0)&& (dateTimeNow < LastTradeEntryTime)) { if (Std4Ticker > StdPerBet) { BreakoutLogger.Log(tickerDB + " has std " + Std4Ticker + " too large for current risk limits! "); return; } PortfolioVarChange = Risk.PorfolioRisk.GetChangeInRiskAfterTickerInclusion(BreakoutPosition.PositionWithAllOrders, CovMatrix, tickerDB, Qty4Ticker); PortfolioStdAfter = Math.Sqrt(Math.Pow(PortfolioStd, 2) + PortfolioVarChange); if (double.IsNaN(PortfolioStdAfter)) { BreakoutLogger.Log("After trading " + tickerDB + " portfolio std would be: " + PortfolioStdAfter); BreakoutLogger.Log("PortfolioStd: " + PortfolioStd); BreakoutLogger.Log("PortfolioVarChange: " + PortfolioVarChange); return; } if (PortfolioStdAfter > PortfolioStdLimit) { BreakoutLogger.Log("After trading " + tickerDB + " portfolio std would be: " + PortfolioStdAfter + " too large!"); return; } else { BreakoutLogger.Log(tickerDB + " trade satisfies risk limit with target portfolio risk: " + PortfolioStdAfter); } BreakoutLogger.Log("Bullish Breakout in " + tickerDB); BreakoutLogger.Log("Range Max: " + rangeMaxList[tickerIndex]); BreakoutLogger.Log("Current Price: " + midPrice); BreakoutLogger.Log("Std 4 Ticker: " + Std4Ticker); if (TotalOrders >= MaxOrdersSent) { BreakoutLogger.Log("Total orders sent : " + TotalOrders + " is not smaller than " + MaxOrdersSent); return; } if (LiveTradingQ) { ttapiUtils.Trade.SendLimitOrder(e.Fields.Instrument, e.Fields.GetBestAskPriceField().Value, Qty4Ticker, ttapiSubs); BreakoutPosition.OrderSend(tickerDB, Qty4Ticker); } else { BreakoutPosition.OrderSend(tickerDB, Qty4Ticker); BreakoutPosition.OrderFill(tickerDB, Qty4Ticker); } PortfolioStd = Risk.PorfolioRisk.GetPortfolioRiskFromCovMatrix(BreakoutPosition.PositionWithAllOrders, CovMatrix); BreakoutLogger.Log("Portfolio Std After Fill: " + PortfolioStd); } else if ((FilledPosition > 0) && (WorkingPosition == 0) && (midPrice < rangeMinList[tickerIndex])) { BreakoutLogger.Log("Pnl in " + tickerDB + ": " + (midPrice - rangeMaxList[tickerIndex]).ToString()); if (LiveTradingQ) { ttapiUtils.Trade.SendLimitOrder(e.Fields.Instrument, e.Fields.GetBestAskPriceField().Value, -(int)FilledPosition, ttapiSubs); BreakoutPosition.OrderSend(tickerDB, -FilledPosition); } else { BreakoutPosition.OrderSend(tickerDB, -FilledPosition); BreakoutPosition.OrderFill(tickerDB, -FilledPosition); } PortfolioStd = Risk.PorfolioRisk.GetPortfolioRiskFromCovMatrix(BreakoutPosition.PositionWithAllOrders, CovMatrix); BreakoutLogger.Log("Portfolio Std After Fill: " + PortfolioStd); } else if ((FilledPosition < 0) && (WorkingPosition == 0) && (midPrice > rangeMaxList[tickerIndex])) { BreakoutLogger.Log("Pnl in " + tickerDB + ": " + (rangeMinList[tickerIndex] - midPrice).ToString()); if (LiveTradingQ) { ttapiUtils.Trade.SendLimitOrder(e.Fields.Instrument, e.Fields.GetBestAskPriceField().Value, -(int)FilledPosition, ttapiSubs); BreakoutPosition.OrderSend(tickerDB, -FilledPosition); } else { BreakoutPosition.OrderSend(tickerDB, -FilledPosition); BreakoutPosition.OrderFill(tickerDB, -FilledPosition); } PortfolioStd = Risk.PorfolioRisk.GetPortfolioRiskFromCovMatrix(BreakoutPosition.PositionWithAllOrders, CovMatrix); BreakoutLogger.Log("Portfolio Std After Fill: " + PortfolioStd); } } else { if (e.Error.IsRecoverableError == false) { Console.WriteLine("Unrecoverable price subscription error: {0}", e.Error.Message); ttapiSubs.Dispose(); } } }
/// <summary> /// Event notification for price update /// </summary> void BreakoutAlgo(object sender, FieldsUpdatedEventArgs e) { if (e.Error == null) { dateTimeNow = DateTime.Now; if ((dateTimeNow - DateTimePastPnlDisplay).Minutes > 10) { DisplayPnl(); DateTimePastPnlDisplay = dateTimeNow; } if (string.IsNullOrEmpty(e.Fields.GetDirectBidPriceField().FormattedValue)) { return; } else { bidPrice = Convert.ToDouble(e.Fields.GetDirectBidPriceField().FormattedValue); } if (string.IsNullOrEmpty(e.Fields.GetDirectAskPriceField().FormattedValue)) { return; } else { askPrice = Convert.ToDouble(e.Fields.GetDirectAskPriceField().FormattedValue); } midPrice = (bidPrice + askPrice) / 2; spreadPrice = askPrice - bidPrice; tickerDB = TA.TickerConverters.ConvertFromTTAPIFields2DB(e.Fields.Instrument.Product.ToString(), e.Fields.Instrument.Name.ToString()); string TickerHead = ContractUtilities.ContractMetaInfo.GetContractSpecs(tickerDB).tickerHead; string ExchangeName = ContractUtilities.ContractMetaInfo.GetExchange4Tickerhead(TickerHead); FilledPosition = BreakoutPosition.GetFilledPosition4Ticker(tickerDB); WorkingPosition = BreakoutPosition.GetWorkingPosition4Ticker(tickerDB); TotalPosition = FilledPosition + WorkingPosition; Std4Ticker = StdDict[tickerDB]; Qty4Ticker = QtyDict[tickerDB]; TotalOrders = BreakoutPosition.PositionWithAllOrders.Select("Qty<>0").Length; int tickerIndex = Enumerable.Range(0, dbTickerList.Count).Where(i => dbTickerList[i] == tickerDB).ToList()[0]; ts = ttapiSubs.TsDictionary[e.Fields.Instrument.Key]; if ((midPrice < rangeMinList[tickerIndex]) && (FilledPosition == 0) && (WorkingPosition == 0) && (dateTimeNow < LastTradeEntryTime)) { if (Std4Ticker > StdPerBet) { BreakoutLogger.Log(tickerDB + " has std " + Std4Ticker + " too large for current risk limits! "); return; } PortfolioVarChange = Risk.PorfolioRisk.GetChangeInRiskAfterTickerInclusion(BreakoutPosition.PositionWithAllOrders, CovMatrix, tickerDB, -Qty4Ticker); PortfolioStdAfter = Math.Sqrt(Math.Pow(PortfolioStd, 2) + PortfolioVarChange); if (double.IsNaN(PortfolioStdAfter)) { BreakoutLogger.Log("After trading " + tickerDB + " portfolio std would be: " + PortfolioStdAfter); BreakoutLogger.Log("PortfolioStd: " + PortfolioStd); BreakoutLogger.Log("PortfolioVarChange: " + PortfolioVarChange); return; } if (PortfolioStdAfter > PortfolioStdLimit) { BreakoutLogger.Log("After trading " + tickerDB + " portfolio std would be: " + PortfolioStdAfter + " too large!"); return; } else { BreakoutLogger.Log(tickerDB + " trade satisfies risk limit with target portfolio risk: " + PortfolioStdAfter); } BreakoutLogger.Log("Bearish Breakout in " + tickerDB); BreakoutLogger.Log("Range Min: " + rangeMinList[tickerIndex]); BreakoutLogger.Log("Current Price: " + midPrice); BreakoutLogger.Log("Std 4 Ticker: " + Std4Ticker); if (TotalOrders >= MaxOrdersSent) { BreakoutLogger.Log("Total orders sent : " + TotalOrders + " is not smaller than " + MaxOrdersSent); return; } if (LiveTradingQ) { ttapiUtils.Trade.SendLimitOrder(e.Fields.Instrument, e.Fields.GetBestAskPriceField().Value, -Qty4Ticker, ttapiSubs); BreakoutPosition.OrderSend(tickerDB, -Qty4Ticker); } else { BreakoutPosition.OrderSend(tickerDB, -Qty4Ticker); BreakoutPosition.OrderFill(tickerDB, -Qty4Ticker); } PortfolioStd = Risk.PorfolioRisk.GetPortfolioRiskFromCovMatrix(BreakoutPosition.PositionWithAllOrders, CovMatrix); BreakoutLogger.Log("Portfolio Std After Fill: " + PortfolioStd); } else if ((midPrice > rangeMaxList[tickerIndex]) && (FilledPosition == 0) && (WorkingPosition == 0) && (dateTimeNow < LastTradeEntryTime)) { if (Std4Ticker > StdPerBet) { BreakoutLogger.Log(tickerDB + " has std " + Std4Ticker + " too large for current risk limits! "); return; } PortfolioVarChange = Risk.PorfolioRisk.GetChangeInRiskAfterTickerInclusion(BreakoutPosition.PositionWithAllOrders, CovMatrix, tickerDB, Qty4Ticker); PortfolioStdAfter = Math.Sqrt(Math.Pow(PortfolioStd, 2) + PortfolioVarChange); if (double.IsNaN(PortfolioStdAfter)) { BreakoutLogger.Log("After trading " + tickerDB + " portfolio std would be: " + PortfolioStdAfter); BreakoutLogger.Log("PortfolioStd: " + PortfolioStd); BreakoutLogger.Log("PortfolioVarChange: " + PortfolioVarChange); return; } if (PortfolioStdAfter > PortfolioStdLimit) { BreakoutLogger.Log("After trading " + tickerDB + " portfolio std would be: " + PortfolioStdAfter + " too large!"); return; } else { BreakoutLogger.Log(tickerDB + " trade satisfies risk limit with target portfolio risk: " + PortfolioStdAfter); } BreakoutLogger.Log("Bullish Breakout in " + tickerDB); BreakoutLogger.Log("Range Max: " + rangeMaxList[tickerIndex]); BreakoutLogger.Log("Current Price: " + midPrice); BreakoutLogger.Log("Std 4 Ticker: " + Std4Ticker); if (TotalOrders >= MaxOrdersSent) { BreakoutLogger.Log("Total orders sent : " + TotalOrders + " is not smaller than " + MaxOrdersSent); return; } if (LiveTradingQ) { ttapiUtils.Trade.SendLimitOrder(e.Fields.Instrument, e.Fields.GetBestAskPriceField().Value, Qty4Ticker, ttapiSubs); BreakoutPosition.OrderSend(tickerDB, Qty4Ticker); } else { BreakoutPosition.OrderSend(tickerDB, Qty4Ticker); BreakoutPosition.OrderFill(tickerDB, Qty4Ticker); } PortfolioStd = Risk.PorfolioRisk.GetPortfolioRiskFromCovMatrix(BreakoutPosition.PositionWithAllOrders, CovMatrix); BreakoutLogger.Log("Portfolio Std After Fill: " + PortfolioStd); } else if ((FilledPosition > 0) && (WorkingPosition == 0) && (midPrice < rangeMinList[tickerIndex])) { BreakoutLogger.Log("Pnl in " + tickerDB + ": " + (midPrice - rangeMaxList[tickerIndex]).ToString()); if (LiveTradingQ) { ttapiUtils.Trade.SendLimitOrder(e.Fields.Instrument, e.Fields.GetBestAskPriceField().Value, -(int)FilledPosition, ttapiSubs); BreakoutPosition.OrderSend(tickerDB, -FilledPosition); } else { BreakoutPosition.OrderSend(tickerDB, -FilledPosition); BreakoutPosition.OrderFill(tickerDB, -FilledPosition); } PortfolioStd = Risk.PorfolioRisk.GetPortfolioRiskFromCovMatrix(BreakoutPosition.PositionWithAllOrders, CovMatrix); BreakoutLogger.Log("Portfolio Std After Fill: " + PortfolioStd); } else if ((FilledPosition < 0) && (WorkingPosition == 0) && (midPrice > rangeMaxList[tickerIndex])) { BreakoutLogger.Log("Pnl in " + tickerDB + ": " + (rangeMinList[tickerIndex] - midPrice).ToString()); if (LiveTradingQ) { ttapiUtils.Trade.SendLimitOrder(e.Fields.Instrument, e.Fields.GetBestAskPriceField().Value, -(int)FilledPosition, ttapiSubs); BreakoutPosition.OrderSend(tickerDB, -FilledPosition); } else { BreakoutPosition.OrderSend(tickerDB, -FilledPosition); BreakoutPosition.OrderFill(tickerDB, -FilledPosition); } PortfolioStd = Risk.PorfolioRisk.GetPortfolioRiskFromCovMatrix(BreakoutPosition.PositionWithAllOrders, CovMatrix); BreakoutLogger.Log("Portfolio Std After Fill: " + PortfolioStd); } } else { if (e.Error.IsRecoverableError == false) { Console.WriteLine("Unrecoverable price subscription error: {0}", e.Error.Message); ttapiSubs.Dispose(); } } }
/// <summary> /// Dispose of all the TT API objects and shutdown the TT API /// </summary> public void shutdownTTAPI() { if (!m_shutdownInProcess) { // Dispose of all request objects if (m_customerDefaultsSubscription != null) { m_customerDefaultsSubscription.CustomerDefaultsChanged -= m_CustomerDefaultsSubscription_CustomerDefaultsChanged; m_customerDefaultsSubscription.Dispose(); m_customerDefaultsSubscription = null; } if (m_instrumentTradeSubscription != null) { m_instrumentTradeSubscription.OrderAdded -= instrumentTradeSubscription_OrderAdded; m_instrumentTradeSubscription.OrderDeleted -= instrumentTradeSubscription_OrderDeleted; m_instrumentTradeSubscription.Dispose(); m_instrumentTradeSubscription = null; } TTAPI.ShutdownCompleted += new EventHandler(TTAPI_ShutdownCompleted); TTAPI.Shutdown(); } // only run shutdown once m_shutdownInProcess = true; }
private void CreateInstrumentTradeSubscription(Instrument instrument) { if (m_instrumentTradeSubscription != null) { m_instrumentTradeSubscription.Dispose(); m_instrumentTradeSubscription = null; } m_instrumentTradeSubscription = new InstrumentTradeSubscription(m_TTAPI.Session, Dispatcher.Current, instrument); m_instrumentTradeSubscription.OrderAdded += new EventHandler<OrderAddedEventArgs>(instrumentTradeSubscription_OrderAdded); m_instrumentTradeSubscription.OrderDeleted += new EventHandler<OrderDeletedEventArgs>(instrumentTradeSubscription_OrderDeleted); }
/// <summary> /// Instrument request completed event. /// </summary> void instrRequest_Completed(object sender, InstrumentLookupSubscriptionEventArgs e) { if (e.IsFinal && e.Instrument != null) { try { UpdateStatusBar("Instrument Found."); Console.WriteLine(String.Format("TT API FindInstrument {0}", e.Instrument.Name)); // Grab the contract specifications and output to the user this.txtExchange.Text = e.Instrument.Product.Market.Name; this.txtProduct.Text = e.Instrument.Product.Name; this.txtProductType.Text = e.Instrument.Product.Type.ToString(); this.txtContract.Text = e.Instrument.GetFormattedName(InstrumentNameFormat.User); if (m_InstrumentTradeSubscription != null) { m_InstrumentTradeSubscription.Dispose(); m_InstrumentTradeSubscription = null; } // populate the order feed dropdown this.cboOrderFeed.Items.Clear(); foreach (OrderFeed orderFeed in e.Instrument.GetValidOrderFeeds()) this.cboOrderFeed.Items.Add(orderFeed); this.cboOrderFeed.SelectedIndex = 0; // This sample will monitor new orders and deleting working orders m_InstrumentTradeSubscription = new InstrumentTradeSubscription(m_TTAPI.Session, Dispatcher.Current, e.Instrument); m_InstrumentTradeSubscription.OrderAdded += new EventHandler<OrderAddedEventArgs>(instrumentTradeSubscription_OrderAdded); m_InstrumentTradeSubscription.OrderDeleted += new EventHandler<OrderDeletedEventArgs>(instrumentTradeSubscription_OrderDeleted); m_InstrumentTradeSubscription.Start(); } catch (Exception err) { Console.WriteLine(String.Format("TT API FindInstrument Exception: {0}", err.Message)); } } else if (e.IsFinal) { Console.WriteLine(String.Format("TT API FindInstrument Instrument Not Found: {0}", e.Error)); } else { Console.WriteLine(String.Format("TT API FindInstrument Instrument Not Found: (Still Searching) {0}", e.Error)); } }
/// <summary> /// Create subscriptions and update the GUI. /// </summary> /// <param name="instrument">Instrument to create subscriptions with.</param> private void instrumentFound(Instrument instrument) { txtExchange.Text = instrument.Key.MarketKey.Name; txtProduct.Text = instrument.Key.ProductKey.Name; txtProductType.Text = instrument.Key.ProductKey.Type.Name; txtContract.Text = instrument.Name; m_priceSubscription = new PriceSubscription(instrument, Dispatcher.Current); m_priceSubscription.FieldsUpdated += new FieldsUpdatedEventHandler(m_priceSubscription_FieldsUpdated); m_priceSubscription.Start(); m_instrumentTradeSubscription = new InstrumentTradeSubscription(m_TTAPI.Session, Dispatcher.Current, instrument); m_instrumentTradeSubscription.OrderAdded += new EventHandler<OrderAddedEventArgs>(m_instrumentTradeSubscription_OrderAdded); m_instrumentTradeSubscription.OrderRejected += new EventHandler<OrderRejectedEventArgs>(m_instrumentTradeSubscription_OrderRejected); m_instrumentTradeSubscription.Start(); populateOrderFeedDropDown(instrument); // Enable the user interface items. txtQuantity.Enabled = true; cboOrderType.Enabled = true; comboBoxOrderFeed.Enabled = true; cboCustomer.Enabled = true; btnBuy.Enabled = true; btnSell.Enabled = true; }
/// <summary> /// Event notification for instrument lookup /// </summary> void m_req_Update(object sender, InstrumentLookupSubscriptionEventArgs e) { if (e.Instrument != null && e.Error == null) { // Instrument was found Console.WriteLine("Found: {0}", e.Instrument.Name); // Subscribe for Inside Market Data m_ps = new PriceSubscription(e.Instrument, Dispatcher.Current); m_ps.Settings = new PriceSubscriptionSettings(PriceSubscriptionType.InsideMarket); m_ps.FieldsUpdated += new FieldsUpdatedEventHandler(m_ps_FieldsUpdated); m_ps.Start(); // Create a TradeSubscription to listen for order / fill events only for orders submitted through it m_ts = new InstrumentTradeSubscription(m_apiInstance.Session, Dispatcher.Current, e.Instrument, true, true, false, false); m_ts.OrderUpdated += new EventHandler<OrderUpdatedEventArgs>(m_ts_OrderUpdated); m_ts.OrderAdded += new EventHandler<OrderAddedEventArgs>(m_ts_OrderAdded); m_ts.OrderDeleted += new EventHandler<OrderDeletedEventArgs>(m_ts_OrderDeleted); m_ts.OrderFilled += new EventHandler<OrderFilledEventArgs>(m_ts_OrderFilled); m_ts.OrderRejected += new EventHandler<OrderRejectedEventArgs>(m_ts_OrderRejected); m_ts.Start(); } else if (e.IsFinal) { // Instrument was not found and TT API has given up looking for it Console.WriteLine("Cannot find instrument: {0}", e.Error.Message); Dispose(); } }
/// <summary> /// Shuts down the TT API /// </summary> public void Dispose() { lock(m_lock) { if (!m_disposed) { // Unattached callbacks and dispose of all subscriptions if (m_req != null) { m_req.Update -= m_req_Update; m_req.Dispose(); m_req = null; } if (m_ps != null) { m_ps.FieldsUpdated -= m_ps_FieldsUpdated; m_ps.Dispose(); m_ps = null; } if (m_ts != null) { m_ts.OrderAdded -= m_ts_OrderAdded; m_ts.OrderDeleted -= m_ts_OrderDeleted; m_ts.OrderFilled -= m_ts_OrderFilled; m_ts.OrderRejected -= m_ts_OrderRejected; m_ts.OrderUpdated -= m_ts_OrderUpdated; m_ts.Dispose(); m_ts = null; } // Begin shutdown the TT API TTAPI.ShutdownCompleted += new EventHandler(TTAPI_ShutdownCompleted); TTAPI.Shutdown(); m_disposed = true; } } }
public void startTradeSubscriptions(object sender, InstrumentLookupSubscriptionEventArgs e) { if (e.Instrument != null && e.Error == null) { // Create a TradeSubscription to listen for order / fill events only for orders submitted through it ts = new InstrumentTradeSubscription(m_apiInstance.Session, Dispatcher.Current, e.Instrument, true, true, false, false); ts.OrderUpdated += new EventHandler<OrderUpdatedEventArgs>(m_ts_OrderUpdated); ts.OrderAdded += new EventHandler<OrderAddedEventArgs>(m_ts_OrderAdded); ts.OrderDeleted += new EventHandler<OrderDeletedEventArgs>(m_ts_OrderDeleted); if (orderFilledEventHandler !=null) { ts.OrderFilled += new EventHandler<OrderFilledEventArgs>(orderFilledEventHandler); } ts.OrderRejected += new EventHandler<OrderRejectedEventArgs>(m_ts_OrderRejected); TsDictionary.Add(e.Instrument.Key,ts); ts.Start(); } else if (e.IsFinal) { // Instrument was not found and TT API has given up looking for it Console.WriteLine("Cannot find instrument: {0}", e.Error.Message); Dispose(); } }