/// <summary>
///
/// </summary>
public DataTickHistoryProvider(ISourceDataDelivery dataDelivery, DataSessionInfo session)
{
_dataDelivery = dataDelivery;
_session = session;
Initialize();
}
void _dataDelivery_OperationalStatusChangedEvent(IOperational operational, OperationalStateEnum previousOperationState)
{
if (operational.OperationalState != OperationalStateEnum.Operational)
{
return;
}
// Re-map the session orderInfo.
RuntimeDataSessionInformation information = _dataDelivery.GetSymbolRuntimeSessionInformation(_symbol);
if (information == null)
{
SystemMonitor.OperationError("Failed to map session information for quote provider.");
_sessionInfo = DataSessionInfo.Empty;
}
else
{
_sessionInfo = information.Info;
if (_dataDelivery.SubscribeToData(_sessionInfo, true, new DataSubscriptionInfo(true, false, null)))
{
RequestQuoteUpdate(false);
}
}
}
void _dataDelivery_QuoteUpdateEvent(ISourceDataDelivery dataDelivery, DataSessionInfo session, Quote?quote)
{
if (session.Symbol == this.Symbol)
{
if (quote.HasValue)
{
lock (this)
{
if (this.Volume < 0)
{
_price = quote.Value.Ask;
}
else
{
_price = quote.Value.Bid;
}
}
}
else
{
_price = null;
}
RecalculateParameters(true);
}
}
void _dataDelivery_QuoteUpdateEvent(ISourceDataDelivery dataDelivery, DataSessionInfo session, Quote?quote)
{
_lastDataQuote = quote;
BeginAccountInfoUpdate(_account.Info);
BeginManagedOrdersUpdate(quote);
}
void _dataDelivery_DataHistoryUpdateEvent(ISourceDataDelivery dataDelivery, DataSessionInfo session, DataHistoryUpdate update)
{
if (update.BarDataAssigned)
{
lock (this)
{
_lastDataBar = update.DataBarsUnsafe[update.DataBarsUnsafe.Count - 1];
}
}
}
/// <summary>
///
/// </summary>
public void FilterUpdate(ISourceDataDelivery dataDelivery, DataSessionInfo session, DataHistoryUpdate update)
{
if (_enabled == false)
{
return;
}
decimal?lastHigh = null;
decimal?lastLow = null;
decimal divergence = MaxDivergenceCoefficientStock;
if (session.Symbol.IsForexPair)
{
divergence = MaxDivergenceCoefficientForex;
}
int consecutiveSpikes = 0;
for (int i = 0; i < update.DataBarsUnsafe.Count; i++)
{
if (lastHigh.HasValue && lastLow.HasValue)
{
DataBar bar = update.DataBarsUnsafe[i];
if ((bar.High > lastHigh.Value * (1 + divergence) || bar.Low < lastLow.Value / (1 + divergence)) &&
consecutiveSpikes <= _maximumConsecutiveSpikes)
{// Bar spike detected.
consecutiveSpikes++;
SystemMonitor.Report("Spike detected in data [" + session.Symbol.Name + "]. Bar values limited to previous [" + lastHigh.Value + ", " + bar.High + "; " + lastLow.Value + ", " + bar.Low + "].");
update.DataBarsUnsafe[i] = new DataBar(bar.DateTime,
GeneralHelper.LimitRange(bar.Open, lastLow.Value, lastHigh.Value),
GeneralHelper.LimitRange(bar.High, lastLow.Value, lastHigh.Value),
GeneralHelper.LimitRange(bar.Low, lastLow.Value, lastHigh.Value),
GeneralHelper.LimitRange(bar.Close, lastLow.Value, lastHigh.Value),
bar.Volume);
}
else
{
consecutiveSpikes = 0;
}
}
lastHigh = update.DataBarsUnsafe[i].High;
lastLow = update.DataBarsUnsafe[i].Low;
}
}
/// <summary>
/// Constructor.
/// </summary>
public DataBarHistoryProvider(ISourceDataDelivery dataDelivery, DataSessionInfo session, TimeSpan period, int?defaultHistoryBarsCount)
{
_sessionInfo = session;
if (defaultHistoryBarsCount.HasValue)
{
_defaultHistoryBarsCount = defaultHistoryBarsCount.Value;
}
_dataDelivery = dataDelivery;
_indicators = new IndicatorManager(this);
_period = period;
Construct();
}
void _dataDelivery_QuoteUpdateEvent(ISourceDataDelivery dataDelivery, DataSessionInfo session, Quote?quote)
{
if (_sessionInfo.Equals(session) == false)
{
return;
}
lock (this)
{
_lastQuoteTime = DateTime.Now;
_currentQuote = quote;
}
if (QuoteUpdateEvent != null)
{
QuoteUpdateEvent(this);
}
}
void _dataDelivery_OperationalStatusChangedEvent(IOperational operational, OperationalStateEnum previousOperationState)
{
if (operational.OperationalState != OperationalStateEnum.Operational)
{
return;
}
if (_sessionInfo.IsEmtpy)
{
SystemMonitor.OperationError("Data bar provider has no valid session assiged.");
return;
}
// Re-map the session orderInfo.
RuntimeDataSessionInformation information = _dataDelivery.GetSymbolRuntimeSessionInformation(_sessionInfo.Symbol);
if (information == null)
{
SystemMonitor.OperationError("Failed to map session information for data provider.");
_sessionInfo = DataSessionInfo.Empty;
return;
}
else
{
_sessionInfo = information.Info;
}
if (_dataDelivery.SubscribeToData(_sessionInfo, true, new DataSubscriptionInfo(false, false, new TimeSpan[] { Period.Value })) == false)
{
SystemMonitor.OperationError("Failed to subscribe to bar data updates.");
return;
}
RuntimeDataSessionInformation session = _dataDelivery.GetSymbolRuntimeSessionInformation(_sessionInfo.Symbol);
if (session != null && session.AvailableDataBarPeriods.Contains(_period.Value))
{
_dataDelivery.RequestDataHistoryUpdate(_sessionInfo, new DataHistoryRequest(_period.Value, _defaultHistoryBarsCount), false);
}
}
/// <summary>
///
/// </summary>
public virtual bool SetInitialParameters(ISourceManager manager, ComponentId sourceId, ExpertSession session)
{
_sessionInfo = session.Info;
_manager = manager;
_sourceId = sourceId;
_dataDelivery = manager.ObtainDataDelivery(sourceId);
_quote = manager.ObtainQuoteProvider(sourceId, _sessionInfo.Symbol);
_tickProvider = manager.ObtainDataTickHistoryProvider(sourceId, _sessionInfo.Symbol);
_dataBarProvider = null;
bool result = _dataDelivery != null && _quote != null && _tickProvider != null;
SystemMonitor.CheckError(result, "Failed to initialize data provider.");
return(result);
}
/// <summary>
/// Constructor.
/// </summary>
public RuntimeDataSessionInformation(DataSessionInfo info)
{
_info = info;
}
protected virtual void dataDelivery_QuoteUpdateEvent(ISourceDataDelivery dataDelivery, DataSessionInfo session, Quote?quote)
{
}
/// <summary>
/// Constructor.
/// </summary>
public RuntimeDataSessionInformation(DataSessionInfo info, IEnumerable <TimeSpan> spans)
{
_info = info;
_availableDataBarPeriods.AddRange(spans);
}
/// <summary>
/// Constructor.
/// </summary>
public ExpertSession(DataSessionInfo sessionInfo)
{
_sessionInfo = sessionInfo;
}
void _dataDelivery_DataHistoryUpdateDelegate(ISourceDataDelivery dataDelivery, DataSessionInfo session, DataHistoryUpdate update)
{
if (session.Equals(_session) == false || update.DataTicksUnsafe.Count == 0)
{
return;
}
DataTickUpdateType?updateType = null;
if (_dataTicks.Count == 0)
{
updateType = DataTickUpdateType.HistoryUpdate;
}
lock (this)
{
_lastDataUpdate = DateTime.Now;
for (int i = 0; i < update.DataTicksUnsafe.Count; i++)
{
if (_dataTicks.Count == 0 || update.DataTicksUnsafe[i].DateTime > _dataTicks[_dataTicks.Count - 1].DateTime)
{
if (updateType.HasValue == false)
{
updateType = DataTickUpdateType.HistoryUpdate;
}
_dataTicks.Add(update.DataTicksUnsafe[i]);
_cachedDataTickIndexSearches.Add(update.DataTicksUnsafe[i].DateTime, i);
}
}
// Also check the last 5 units for any requotes that might have been sent,
// this happens when price changes and we get updates for the last unit.
for (int i = 0; i < 5 && update.DataTicksUnsafe.Count - 1 - i > 0 && _dataTicks.Count - 1 - i > 0; i++)
{
if (update.DataTicksUnsafe[update.DataTicksUnsafe.Count - 1 - i].DateTime == _dataTicks[_dataTicks.Count - 1 - i].DateTime &&
update.DataTicksUnsafe[update.DataTicksUnsafe.Count - 1 - i].Equals(_dataTicks[_dataTicks.Count - 1 - i]) == false)
{
// Since this update is only when the date times are the same, the helper cache dictionary needs not be updated.
_dataTicks[_dataTicks.Count - 1 - i] = update.DataTicksUnsafe[update.DataTicksUnsafe.Count - 1 - i];
if (updateType.HasValue == false)
{
updateType = DataTickUpdateType.HistoryUpdate;
}
}
}
}
if (updateType.HasValue && DataTickHistoryUpdateEvent != null)
{
DataTickHistoryUpdateEvent(this, updateType.Value);
}
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="orderInfo"></param>
/// <param name="spans"></param>
public RuntimeDataSessionInformation(DataSessionInfo info, TimeSpan period)
{
_info = info;
_availableDataBarPeriods.Add(period);
}
/// <summary>
/// Constructor.
/// </summary>
public QuoteProvider(DataSessionInfo sessionInfo)
{// Make sure this dataDelivery keeper is in the same state as its dataDelivery delivery.
_sessionInfo = sessionInfo;
_symbol = _sessionInfo.Symbol;
}
/// <summary>
/// Data delivery has received a dataDelivery update.
/// </summary>
void _dataDelivery_DataHistoryUpdateDelegate(ISourceDataDelivery dataDelivery, DataSessionInfo session, DataHistoryUpdate update)
{
if (_sessionInfo.Equals(session) == false)
{
return;
}
if (update.Period != _period.Value)
{// This update is aimed at another provider.
return;
}
DataBarUpdateType?updateType = null;
if (_dataBars.Count == 0)
{
updateType = DataBarUpdateType.Initial;
}
_barFilter.FilterUpdate(dataDelivery, session, update);
int updatedBarsCount = 0;
lock (this)
{
_lastDataUpdate = DateTime.Now;
// Add new bars - search for new later bars.
for (int i = 0; i < update.DataBarsUnsafe.Count; i++)
{
if (_dataBars.Count == 0 || update.DataBarsUnsafe[i].DateTime > _dataBars[_dataBars.Count - 1].DateTime)
{
if (updateType.HasValue == false)
{
updateType = DataBarUpdateType.HistoryUpdate;
}
updatedBarsCount++;
_dataBars.Add(update.DataBarsUnsafe[i]);
_cachedDataBarIndexSearches.Add(update.DataBarsUnsafe[i].DateTime, _dataBars.Count - 1);
}
}
bool preTimeUpdate = false;
// Add new bars - search for previous bars - a separate cycle needed since we need to move backwards on this.
for (int i = update.DataBarsUnsafe.Count - 1; i >= 0; i--)
{
if (_dataBars.Count > 0 && update.DataBarsUnsafe[i].DateTime < _dataBars[0].DateTime)
{// This is a bar from previous history, we do not know about - insert first place.
_dataBars.Insert(0, update.DataBarsUnsafe[i]);
preTimeUpdate = true;
}
}
// Also check the last 5 units for any requotes that might have been sent,
// this happens when price changes and we get updates for the last unit.
for (int i = 0; i < 5 && update.DataBarsUnsafe.Count - 1 - i > 0 && _dataBars.Count - 1 - i > 0; i++)
{
if (update.DataBarsUnsafe[update.DataBarsUnsafe.Count - 1 - i].DateTime == _dataBars[_dataBars.Count - 1 - i].DateTime
/*&& update.DataBarsUnsafe[update.DataBarsUnsafe.Count - 1 - i].Equals(_dataBars[_dataBars.Count - 1 - i]) == false*/)
{
updatedBarsCount++;
// Since this update is only when the date times are the same, the helper cache dictionary needs not be updated.
_dataBars[_dataBars.Count - 1 - i] = update.DataBarsUnsafe[update.DataBarsUnsafe.Count - 1 - i];
if (updateType.HasValue == false)
{
updateType = DataBarUpdateType.HistoryUpdate;
}
}
}
if (preTimeUpdate)
{// Make a full update if we have inserted something in the beggining.
updateType = DataBarUpdateType.HistoryUpdate;
updatedBarsCount = _dataBars.Count;
}
}
if (updateType.HasValue && DataBarHistoryUpdateEvent != null)
{
DataBarHistoryUpdateEvent(this, updateType.Value, updatedBarsCount);
}
}
/// <summary>
/// Follow quotes update.
/// </summary>
void _dataDelivery_QuoteUpdateEvent(ISourceDataDelivery dataDelivery, DataSessionInfo session, Quote?quote)
{
if (_sessionInfo.Equals(session) == false || _period.HasValue == false ||
quote.HasValue == false)
{
return;
}
DataBar?lastBar = null;
if (_dataBars.Count > 0)
{
lastBar = _dataBars[_dataBars.Count - 1];
}
else
{// If there are no existing bars, we do not operate, to evade mixing up start / end period etc.
return;
}
TimeSpan?period = _period;
DataBarUpdateType?updateType = null;
// The time of a bar is its open time, so everything after a "period" closeVolume of time after it is part of that bar.
if (lastBar.Value.DateTime + period < quote.Value.Time)
{// We need to append a new bar.
DateTime newBarDateTime = lastBar.Value.DateTime;
int i = 0;
while (newBarDateTime.Add(period.Value) < quote.Value.Time)
{// Establish end time of new bar (max 1000 steps to evade potential lockups).
newBarDateTime = newBarDateTime.Add(period.Value);
i++;
if (i > 1000)
{// We have tried and failed to establish proper new period so just abort.
SystemMonitor.OperationError("We have tried and failed to establish proper new period so quote aborted.");
return;
}
}
DataBar?newBar = BarFromQuote(lastBar, newBarDateTime, quote.Value);
if (newBar.HasValue == false)
{// Failed to establish bar from quote.
return;
}
updateType = DataBarUpdateType.NewPeriod;
lock (this)
{// Add the new bar.
_lastDataUpdate = DateTime.Now;
_dataBars.Add(newBar.Value);
}
}
else
{
updateType = DataBarUpdateType.CurrentBarUpdate;
lock (this)
{// Just update the current last bar.
_lastDataUpdate = DateTime.Now;
_dataBars[_dataBars.Count - 1] = UpdateCurrentBar(lastBar.Value, quote.Value);
}
}
if (updateType.HasValue && DataBarHistoryUpdateEvent != null)
{
DataBarHistoryUpdateEvent(this, updateType.Value, 1);
}
}
protected override void dataDelivery_QuoteUpdateEvent(ISourceDataDelivery dataDelivery, DataSessionInfo session, Quote?quote)
{
base.dataDelivery_QuoteUpdateEvent(dataDelivery, session, quote);
DoUpdate();
}
/// <summary>
/// Will calculate the result of this execution up until now, against the values of the provider.
/// </summary>
/// <param name="provider"></param>
/// <returns></returns>
public decimal?GetPendingResult(IQuoteProvider provider, Order.ResultModeEnum mode, DataSessionInfo info)
{
if (this.IsEmpty || _executedPrice.HasValue == false || this._executedPrice == 0 || provider == null)
{
return(null);
}
return(Order.GetResult(mode, _executedPrice, null, _volumeExecuted, Symbol, OrderStateEnum.Executed, OrderType, null, Symbol.Empty,
info.LotSize, info.DecimalPlaces, provider.Ask, provider.Bid));
}