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);
}
}
}
/// <summary>
/// Deserialization constructor.
/// </summary>
public LiveDemoSource(SerializationInfo info, StreamingContext context)
: base(info, context)
{
_sessionInformation = (RuntimeDataSessionInformation)info.GetValue("sessionInformation", typeof(RuntimeDataSessionInformation));
_dataStub = (DataSourceStub)info.GetValue("dataStub", typeof(DataSourceStub));
Construct();
}
/// <summary>
/// Constructor.
/// </summary>
public LiveDemoDataAdapter()
{
DataSourceStub stub = new DataSourceStub("Live Demo Data Source", false);
_sessionInformation = new RuntimeDataSessionInformation(new DataSessionInfo(Guid.NewGuid(), "DEMO150", new Symbol("Unknown", "DEMO10D15"), 10000, 4), _period);
base.SetStub(stub);
Construct();
}
/// <summary>
/// Constructor.
/// </summary>
public LiveDemoDataAdapter(SerializationInfo info, StreamingContext context)
: base(info, context)
{
_sessionInformation = (RuntimeDataSessionInformation)info.GetValue("sessionInformation", typeof(RuntimeDataSessionInformation));
Construct();
// Make sure to run Construct first, since it creates the timer instance.
_liveDataTimer.Interval = info.GetDouble("timerInterval");
}
/// <summary>
///
/// </summary>
/// <param name="period"></param>
/// <returns></returns>
public bool ObtainDataBarProvider(TimeSpan period)
{
lock (this)
{
RuntimeDataSessionInformation sessionInfo = _dataDelivery.GetSymbolRuntimeSessionInformation(SessionInfo.Symbol);
if (sessionInfo == null)
{
SystemMonitor.OperationError("Failed to retrieve runtime session information for symbol [" + SessionInfo.Symbol.Name + "].");
return(false);
}
if (false == sessionInfo.AvailableDataBarPeriods.Contains(period))
{
SystemMonitor.OperationError("Period not available for data bar provider creation.");
return(false);
}
}
IDataBarHistoryProvider provider;
lock (this)
{
if (_dataBarProviders.ContainsKey(period))
{
SystemMonitor.OperationError("Period data bar already created.");
return(false);
}
provider = _manager.ObtainDataBarHistoryProvider(_dataDelivery.SourceId,
_sessionInfo.Symbol, period);
_dataBarProviders.Add(period, provider);
}
if (_dataBarProvider == null)
{
SetCurrentDataBarProvider(period);
}
if (DataBarProviderCreatedEvent != null)
{
DataBarProviderCreatedEvent(this, provider);
}
return(true);
}
/// <summary>
///
/// </summary>
/// <param name="other"></param>
/// <returns></returns>
public bool EqualAvailableDataBarPeriods(RuntimeDataSessionInformation other)
{
if (other.AvailableDataBarPeriods.Count != AvailableDataBarPeriods.Count)
{
return(false);
}
for (int i = 0; i < other.AvailableDataBarPeriods.Count; i++)
{
if (AvailableDataBarPeriods[i] != other.AvailableDataBarPeriods[i])
{
return(false);
}
}
return(true);
}
void _dataDelivery_OperationalStatusChangedEvent(IOperational operational, OperationalStateEnum previousOperationState)
{
if (operational.OperationalState != OperationalStateEnum.Operational)
{
return;
}
RuntimeDataSessionInformation info = _dataDelivery.GetSymbolRuntimeSessionInformation(_session.Symbol);
if (info != null)
{
if (info.TickDataAvailabe)
{
_dataDelivery.RequestDataHistoryUpdate(_session, new DataHistoryRequest(TimeSpan.Zero, null), false);
}
}
else
{
SystemMonitor.OperationError("Failed to estblish runtime data session information.");
}
}
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>
bool GetProviders(Symbol symbol, out IQuoteProvider quotes, out IDataBarHistoryProvider bars)
{
quotes = _manager.ObtainQuoteProvider(_dataDelivery.SourceId, symbol);
RuntimeDataSessionInformation sessionInformation = _dataDelivery.GetSymbolRuntimeSessionInformation(symbol);
if (sessionInformation.AvailableDataBarPeriods == null || sessionInformation.AvailableDataBarPeriods.Count == 0)
{
quotes = null;
bars = null;
SystemMonitor.OperationError("Can not close order since no suitable data provider sessions found.");
return(false);
}
bars = _manager.ObtainDataBarHistoryProvider(_dataDelivery.SourceId, symbol, sessionInformation.AvailableDataBarPeriods[0]);
if (quotes == null || quotes.Ask.HasValue == false || bars == null)
{
return(false);
}
return(true);
}
/// <summary>
///
/// </summary>
/// <returns></returns>
bool DoAddEntry(DataStoreEntry entry)
{
entry.Initialize(_dataStoreFilesFolder);
lock(_entriesAndSessions)
{
if (_entriesAndSessions.ContainsKey(entry))
{
SystemMonitor.OperationWarning("Entry already added.");
return false;
}
if (entry.Symbol.IsEmpty)
{
SystemMonitor.Warning("Entry added before initialized.");
return false;
}
// The sessionInformation reuses the entry Guid, so that it can be easily persisted further.
DataSessionInfo entrySessionInfo = new DataSessionInfo(entry.Guid, "Data Store Session [" + entry.Symbol.Name + "]",
entry.Symbol, DefaultSessionLotSize, entry.DecimalDigits);
RuntimeDataSessionInformation session = new RuntimeDataSessionInformation(entrySessionInfo, entry.Period.Value);
_entriesAndSessions.Add(entry, session);
}
return true;
}
/// <summary>
/// Constructor.
/// </summary>
public LiveDemoSource()
{
_dataStub = new DataSourceStub(Name, false);
_sessionInformation = new RuntimeDataSessionInformation(new DataSessionInfo(Guid.NewGuid(), "DEMO150", new Symbol("Unknown", "DEMO10D15"), 10000, 4), _period);
Construct();
}
/// <summary>
///
/// </summary>
public void AddSession(RuntimeDataSessionInformation sessionInformation)
{
lock (this)
{
_symbolsRunningSessions[sessionInformation.Info.Symbol] = new CombinedDataSubscriptionInformation(sessionInformation);
}
}
public bool InitializeIntegrationSession(string symbol,
decimal modePoint, decimal modeDigits, decimal modeSpread, decimal modeStopLevel, decimal modeLotSize, decimal modeTickValue,
decimal modeTickSize, decimal modeSwapLong, decimal modeSwapShort, decimal modeStarting, decimal modeExpiration,
decimal modeTradeAllowed, decimal modeMinLot, decimal modeLotStep, decimal modeMaxLot, decimal modeSwapType,
decimal modeProfitCalcMode, decimal modeMarginCalcMode, decimal modeMarginInit, decimal modeMarginMaintenance,
decimal modeMarginHedged, decimal modeMarginRequired, decimal modeFreezeLevel)
{
TracerHelper.Trace(symbol);
CombinedDataSubscriptionInformation session = GetDataSession(symbol);
if (session == null)
{
DataSessionInfo sessionInfo = new DataSessionInfo(Guid.NewGuid(), symbol,
CreateSymbol(symbol), modeLotSize, (int)modeDigits);
RuntimeDataSessionInformation runtimeSession = new RuntimeDataSessionInformation(sessionInfo);
session = new CombinedDataSubscriptionInformation(runtimeSession);
lock (this)
{
_dataSessions.Add(sessionInfo.Symbol, session);
}
}
return true;
}
/// <summary>
///
/// </summary>
/// <param name="other"></param>
/// <returns></returns>
public bool EqualAvailableDataBarPeriods(RuntimeDataSessionInformation other)
{
if (other.AvailableDataBarPeriods.Count != AvailableDataBarPeriods.Count)
{
return false;
}
for (int i = 0; i < other.AvailableDataBarPeriods.Count; i++)
{
if (AvailableDataBarPeriods[i] != other.AvailableDataBarPeriods[i])
{
return false;
}
}
return true;
}
/// <summary>
///
/// </summary>
public RuntimeDataSessionInformation GetSymbolSessionRuntimeInformation(Symbol inputSymbol)
{
// Filter the baseCurrency trough its name and what symbols we know of.
Symbol? knownSymbol = EstablishSymbolUsage(inputSymbol, TimeSpan.FromSeconds(6));
if (knownSymbol.HasValue == false)
{// Failed to start / establish symbol usage.
return null;
}
DataSessionInfo sessionInfo = new DataSessionInfo(Guid.NewGuid(), knownSymbol.Value.Name,
knownSymbol.Value, DefaultLotSize, 5);
RuntimeDataSessionInformation session = new RuntimeDataSessionInformation(sessionInfo);
session.AvailableDataBarPeriods.AddRange(DefaultAvailablePeriods);
return session;
}
/// <summary>
///
/// </summary>
public CombinedDataSubscriptionInformation(RuntimeDataSessionInformation sessionInformation)
{
_sessionInformation = sessionInformation;
}
