TickDataSubscriptionTest.cs

#region Using declarations
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Input;
using System.Windows.Media;
using System.Xml.Serialization;
using NinjaTrader.Cbi;
using NinjaTrader.Gui;
using NinjaTrader.Gui.Chart;
using NinjaTrader.Gui.SuperDom;
using NinjaTrader.Gui.Tools;
using NinjaTrader.Data;
using NinjaTrader.NinjaScript;
using NinjaTrader.Core.FloatingPoint;
using NinjaTrader.NinjaScript.DrawingTools;
using System.Reflection;
using System.Threading;
#endregion

namespace NinjaTrader.NinjaScript.Indicators {
    public static class BarsExtensions {

        static readonly object[] noParameteres = new object[0];
        static readonly MethodInfo barsSeriesGetter = typeof(Bars).GetProperty("BarsSeries").GetGetMethod();

        public static NinjaTrader.Data.BarsSeries GetBarsSeries(this Bars bars) {
            return (BarsSeries)barsSeriesGetter.Invoke(bars, noParameteres);
        }

        public static bool IsMarketDataSubscribed(this Bars bars) {
            return bars.GetBarsSeries().IsMarketDataSubscribed;
        }
    }

    public class TickDataSubscriptionTest : Indicator {

        BarsRequest request;
        ErrorCode requestErrorCode;
        Bars requestBars;
        ConnectionStatus connectionStatus;
        bool isExperimentKilledByReload = false;
        int initialRequestBarsCount;
        int numNewTicks = 0;
        DateTime timeOfLastBackgroundUpdate;
        DateTime timeOfLastChartUpdate;

        protected override void OnStateChange() {
            switch (State) {

                case State.SetDefaults:
                    Name = "Tick Data Subscription Test";
                    Calculate = Calculate.OnEachTick;
                    IsOverlay = true;
                    DrawOnPricePanel = true;
                    break;

                case State.Configure:
                    break;

                case State.DataLoaded:
                    SetupBarsRequest();
                    StartWork();
                    break;

                case State.Terminated:
                    if (null != request) {
                        request.Dispose();
                        BarsSeries.RepositoryReloaded -= BarsSeries_RepositoryReloaded;
                    }
                    break;
            }
        }

        void SetupBarsRequest() {
            BarsSeries.RepositoryReloaded += BarsSeries_RepositoryReloaded;
            var startDate = DateTime.Now.Date.AddDays(-5);
            var endDate = DateTime.Now.Date.AddDays(30);
            request = new BarsRequest(Instrument, startDate, endDate);
            request.BarsPeriod = new BarsPeriod { BarsPeriodType = BarsPeriodType.Tick, Value = 1, };
            request.IsDividendAdjusted = true;
            request.IsResetOnNewTradingDay = true;
            request.IsSplitAdjusted = true;
            request.LookupPolicy = LookupPolicies.Provider | LookupPolicies.Repository;
            request.MergePolicy = MergePolicy.MergeBackAdjusted;
            request.TradingHours = TradingHours.Get(TradingHours.SystemDefault);
            request.Update += request_Update; // adding this handler is required to make the request bars update with live data
            request.Request(Request_Callback);
        }

        void BarsSeries_RepositoryReloaded(object sender, RepositoryReloadedEventArgs e) {
            if (e.MasterInstrument == Instrument.MasterInstrument) {
                BarsSeries.RepositoryReloaded -= BarsSeries_RepositoryReloaded;
                isExperimentKilledByReload = true;
                Print(NowString() + " Bars reloaded at datasource. Experiment killed. F5 to refresh please.");
                request.Dispose();
            }
        }

        void Request_Callback(BarsRequest r, ErrorCode errorCode, string message) {

            if (State >= State.Terminated) return;
            requestErrorCode = errorCode;
            Print(NowString() + " requestErrorCode: " + errorCode.ToString());


            if (errorCode == ErrorCode.NoError) {
                requestBars = request.Bars;
                initialRequestBarsCount = requestBars.Count;
            }
        }

        void request_Update(object sender, BarsUpdateEventArgs args) {
            timeOfLastBackgroundUpdate = DateTime.Now;
        }

        void StartWork() {
            Task.Run(() => {
                while (true) {
                    if (State >= State.Terminated) break;
                    ForceRefresh();
                    Thread.Sleep(500);
                }
            });
        }

        protected override void OnConnectionStatusUpdate(Cbi.ConnectionStatusEventArgs args) {
            connectionStatus = args.Status;
            Print(NowString() + " ConnectionStatus: " + args.Status.ToString());
        }

        protected override void OnBarUpdate() {
            if (State == State.Realtime && null != requestBars) {
                numNewTicks++;
                timeOfLastChartUpdate = DateTime.Now;
            }
        }

        protected override void OnRender(ChartControl chartControl, ChartScale chartScale) {
            Draw.TextFixed(this, "status", GetStatus(), TextPosition.BottomRight);
            base.OnRender(chartControl, chartScale);
        }

        string GetStatus() {
            if (null == request) return "Request not created";
            if (isExperimentKilledByReload) return "Experiment killed by bars reload a the data source. Press F5 please.";
            if (requestErrorCode != ErrorCode.NoError) return "Request Error: " + requestErrorCode.ToString();
            if (null == requestBars) return "Waiting for request bars to load";
            var updateTimeDifference = timeOfLastChartUpdate.Subtract(timeOfLastBackgroundUpdate).TotalMinutes;
            if (updateTimeDifference > 1) return "Request bars stopped updating!!! --> " + updateTimeDifference.ToString("F") + " minutes have passed without a request bars update";
            var format = "ConnectionStatus: {0}, RequestBarsSubscribed: {1}, Num New Tick Bars: {2}, Expected Num New Tick Bars: {3}";
            return string.Format(format, connectionStatus, requestBars.IsMarketDataSubscribed(), requestBars.Count - initialRequestBarsCount, numNewTicks);
        }

        string NowString() {
            return DateTime.Now.ToString("HH:mm:ss");
        }

    }
}

#region NinjaScript generated code. Neither change nor remove.

namespace NinjaTrader.NinjaScript.Indicators {
    public partial class Indicator : NinjaTrader.Gui.NinjaScript.IndicatorRenderBase {
        private TickDataSubscriptionTest[] cacheTickDataSubscriptionTest;
        public TickDataSubscriptionTest TickDataSubscriptionTest() {
            return TickDataSubscriptionTest(Input);
        }

        public TickDataSubscriptionTest TickDataSubscriptionTest(ISeries<double> input) {
            if (cacheTickDataSubscriptionTest != null)
                for (int idx = 0; idx < cacheTickDataSubscriptionTest.Length; idx++)
                    if (cacheTickDataSubscriptionTest[idx] != null && cacheTickDataSubscriptionTest[idx].EqualsInput(input))
                        return cacheTickDataSubscriptionTest[idx];
            return CacheIndicator<TickDataSubscriptionTest>(new TickDataSubscriptionTest(), input, ref cacheTickDataSubscriptionTest);
        }
    }
}

namespace NinjaTrader.NinjaScript.MarketAnalyzerColumns {
    public partial class MarketAnalyzerColumn : MarketAnalyzerColumnBase {
        public Indicators.TickDataSubscriptionTest TickDataSubscriptionTest() {
            return indicator.TickDataSubscriptionTest(Input);
        }

        public Indicators.TickDataSubscriptionTest TickDataSubscriptionTest(ISeries<double> input) {
            return indicator.TickDataSubscriptionTest(input);
        }
    }
}

namespace NinjaTrader.NinjaScript.Strategies {
    public partial class Strategy : NinjaTrader.Gui.NinjaScript.StrategyRenderBase {
        public Indicators.TickDataSubscriptionTest TickDataSubscriptionTest() {
            return indicator.TickDataSubscriptionTest(Input);
        }

        public Indicators.TickDataSubscriptionTest TickDataSubscriptionTest(ISeries<double> input) {
            return indicator.TickDataSubscriptionTest(input);
        }
    }
}

#endregion