/// <summary>
/// To get data.
/// </summary>
/// <param name="series">Candles series.</param>
/// <param name="from">The initial date from which you need to get data.</param>
/// <param name="to">The final date by which you need to get data.</param>
/// <returns>Data. If data does not exist for the specified range then <see langword="null" /> will be returned.</returns>
protected override IEnumerable <Trade> GetValues(CandleSeries series, DateTimeOffset from, DateTimeOffset to)
{
var storage = StorageRegistry.GetOrderLogStorage(series.Security, Drive);
var range = storage.GetRange(from, to);
if (range == null)
{
return(null);
}
return(storage.Load(range.Min, range.Max).ToTrades());
}
/// <summary>
/// To get time ranges for which this source of passed candles series has data.
/// </summary>
/// <param name="series">Candles series.</param>
/// <returns>Time ranges.</returns>
public override IEnumerable <Range <DateTimeOffset> > GetSupportedRanges(CandleSeries series)
{
if (series == null)
{
throw new ArgumentNullException(nameof(series));
}
if (StorageRegistry == null)
{
return(Enumerable.Empty <Range <DateTimeOffset> >());
}
return(StorageRegistry.GetOrderLogStorage(series.Security, Drive).GetRanges());
}
private void ProcessMarketDataMessage(MarketDataMessage message)
{
var security = _sessionHolder.SecurityProvider.LookupById(message.SecurityId.SecurityCode + "@" + message.SecurityId.BoardCode);
if (security == null)
{
RaiseMarketDataMessage(message, new InvalidOperationException(LocalizedStrings.Str704Params.Put(message.SecurityId)));
return;
}
if (TryGetGenerator(message) != null)
{
RaiseMarketDataMessage(message, null);
return;
}
if (StorageRegistry == null)
{
RaiseMarketDataMessage(message, new InvalidOperationException(LocalizedStrings.Str1117Params.Put(message.DataType, message.SecurityId)));
return;
}
Exception error = null;
switch (message.DataType)
{
case MarketDataTypes.Level1:
{
if (message.IsSubscribe)
{
_basketStorage.InnerStorages.Add(StorageRegistry.GetLevel1MessageStorage(security, Drive, StorageFormat));
_basketStorage.InnerStorages.Add(new InMemoryMarketDataStorage <ClearingMessage>(date => new[]
{
new ClearingMessage
{
LocalTime = date.Date + security.Board.ExpiryTime,
SecurityId = message.SecurityId,
ClearMarketDepth = true
}
}));
}
else
{
RemoveStorage <IMarketDataStorage <Level1ChangeMessage> >(security, MessageTypes.Level1Change, message.Arg);
RemoveStorage <InMemoryMarketDataStorage <ClearingMessage> >(security, ExtendedMessageTypes.Clearing, message.Arg);
}
break;
}
case MarketDataTypes.MarketDepth:
{
if (message.IsSubscribe)
{
_basketStorage.InnerStorages.Add((IMarketDataStorage <QuoteChangeMessage>)StorageRegistry.GetMarketDepthStorage(security, Drive, StorageFormat));
}
else
{
RemoveStorage <IMarketDataStorage <QuoteChangeMessage> >(security, MessageTypes.QuoteChange, message.Arg);
}
break;
}
case MarketDataTypes.Trades:
{
if (message.IsSubscribe)
{
_basketStorage.InnerStorages.Add((IMarketDataStorage <ExecutionMessage>)StorageRegistry.GetTradeStorage(security, Drive, StorageFormat));
}
else
{
RemoveStorage <IMarketDataStorage <ExecutionMessage> >(security, MessageTypes.Execution, message.Arg);
}
break;
}
case MarketDataTypes.OrderLog:
{
if (message.IsSubscribe)
{
//var msg = "OrderLog".ValidateLicense();
//if (msg == null)
_basketStorage.InnerStorages.Add((IMarketDataStorage <ExecutionMessage>)StorageRegistry.GetOrderLogStorage(security, Drive, StorageFormat));
//else
// SessionHolder.AddErrorLog(msg);
}
else
{
RemoveStorage <IMarketDataStorage <ExecutionMessage> >(security, MessageTypes.Execution, message.Arg);
}
break;
}
case MarketDataTypes.CandleTimeFrame:
case MarketDataTypes.CandleTick:
case MarketDataTypes.CandleVolume:
case MarketDataTypes.CandleRange:
case MarketDataTypes.CandlePnF:
case MarketDataTypes.CandleRenko:
{
Type candleMessageType;
MessageTypes msgType;
switch (message.DataType)
{
case MarketDataTypes.CandleTimeFrame:
msgType = MessageTypes.CandleTimeFrame;
candleMessageType = typeof(TimeFrameCandleMessage);
break;
case MarketDataTypes.CandleTick:
msgType = MessageTypes.CandleTick;
candleMessageType = typeof(TickCandleMessage);
break;
case MarketDataTypes.CandleVolume:
msgType = MessageTypes.CandleVolume;
candleMessageType = typeof(VolumeCandleMessage);
break;
case MarketDataTypes.CandleRange:
msgType = MessageTypes.CandleRange;
candleMessageType = typeof(RangeCandleMessage);
break;
case MarketDataTypes.CandlePnF:
msgType = MessageTypes.CandlePnF;
candleMessageType = typeof(PnFCandleMessage);
break;
case MarketDataTypes.CandleRenko:
msgType = MessageTypes.CandleRenko;
candleMessageType = typeof(RenkoCandleMessage);
break;
default:
throw new InvalidOperationException();
}
if (message.IsSubscribe)
{
_basketStorage.InnerStorages.Add(StorageRegistry.GetCandleMessageStorage(candleMessageType, security, message.Arg, Drive, StorageFormat));
}
else
{
RemoveStorage <IMarketDataStorage <CandleMessage> >(security, msgType, message.Arg);
}
break;
}
default:
error = new InvalidOperationException(LocalizedStrings.Str1118Params.Put(message.DataType));
break;
}
RaiseMarketDataMessage(message, error);
}
private void ProcessMarketDataMessage(MarketDataMessage message)
{
var securityId = message.SecurityId;
var security = SecurityProvider.LookupById(securityId.ToStringId());
if (security == null)
{
RaiseMarketDataMessage(message, new InvalidOperationException(LocalizedStrings.Str704Params.Put(securityId)));
return;
}
if (StorageRegistry == null)
{
RaiseMarketDataMessage(message, new InvalidOperationException(LocalizedStrings.Str1117Params.Put(message.DataType, securityId)));
return;
}
var history = message as HistorySourceMessage;
var storages = BasketStorage.InnerStorages;
Exception error = null;
switch (message.DataType)
{
case MarketDataTypes.Level1:
{
if (message.IsSubscribe)
{
if (history == null)
{
storages.Add(StorageRegistry.GetLevel1MessageStorage(security, Drive, StorageFormat));
storages.Add(new InMemoryMarketDataStorage <ClearingMessage>(security, null, date => new[]
{
new ClearingMessage
{
LocalTime = date.Date + security.Board.ExpiryTime,
SecurityId = securityId,
ClearMarketDepth = true
}
}));
}
else
{
storages.Add(new InMemoryMarketDataStorage <Level1ChangeMessage>(security, null, history.GetMessages));
}
}
else
{
RemoveStorage <IMarketDataStorage <Level1ChangeMessage> >(security, MessageTypes.Level1Change, null);
RemoveStorage <InMemoryMarketDataStorage <ClearingMessage> >(security, ExtendedMessageTypes.Clearing, null);
}
break;
}
case MarketDataTypes.MarketDepth:
{
if (message.IsSubscribe)
{
if (history == null)
{
storages.Add((IMarketDataStorage <QuoteChangeMessage>)StorageRegistry.GetMarketDepthStorage(security, Drive, StorageFormat));
}
else
{
storages.Add(new InMemoryMarketDataStorage <QuoteChangeMessage>(security, null, history.GetMessages));
}
}
else
{
RemoveStorage <IMarketDataStorage <QuoteChangeMessage> >(security, MessageTypes.QuoteChange, null);
}
break;
}
case MarketDataTypes.Trades:
{
if (message.IsSubscribe)
{
if (history == null)
{
storages.Add((IMarketDataStorage <ExecutionMessage>)StorageRegistry.GetTradeStorage(security, Drive, StorageFormat));
}
else
{
storages.Add(new InMemoryMarketDataStorage <ExecutionMessage>(security, null, history.GetMessages));
}
}
else
{
RemoveStorage <IMarketDataStorage <ExecutionMessage> >(security, MessageTypes.Execution, ExecutionTypes.Tick);
}
break;
}
case MarketDataTypes.OrderLog:
{
if (message.IsSubscribe)
{
if (history == null)
{
storages.Add((IMarketDataStorage <ExecutionMessage>)StorageRegistry.GetOrderLogStorage(security, Drive, StorageFormat));
}
else
{
storages.Add(new InMemoryMarketDataStorage <ExecutionMessage>(security, null, history.GetMessages));
}
}
else
{
RemoveStorage <IMarketDataStorage <ExecutionMessage> >(security, MessageTypes.Execution, ExecutionTypes.OrderLog);
}
break;
}
case MarketDataTypes.CandleTimeFrame:
case MarketDataTypes.CandleTick:
case MarketDataTypes.CandleVolume:
case MarketDataTypes.CandleRange:
case MarketDataTypes.CandlePnF:
case MarketDataTypes.CandleRenko:
{
var msgType = message.DataType.ToCandleMessageType();
if (message.IsSubscribe)
{
var candleType = message.DataType.ToCandleMessage();
if (history == null)
{
storages.Add(StorageRegistry.GetCandleMessageStorage(candleType, security, message.Arg, Drive, StorageFormat));
}
else
{
storages.Add(new InMemoryMarketDataStorage <CandleMessage>(security, message.Arg, history.GetMessages, candleType));
}
}
else
{
RemoveStorage <IMarketDataStorage <CandleMessage> >(security, msgType, message.Arg);
}
break;
}
default:
error = new InvalidOperationException(LocalizedStrings.Str1118Params.Put(message.DataType));
break;
}
RaiseMarketDataMessage(message, error);
}
private void ProcessMarketDataMessage(MarketDataMessage message)
{
var generatorMessage = message as GeneratorMarketDataMessage;
if (generatorMessage != null)
{
if (generatorMessage.Generator == null)
{
throw new ArgumentException("message");
}
var tradeGen = generatorMessage.Generator as TradeGenerator;
if (tradeGen != null)
{
if (generatorMessage.IsSubscribe)
{
_tradeGenerators.Add(generatorMessage.SecurityId, tradeGen);
}
else
{
_tradeGenerators.Remove(generatorMessage.SecurityId);
}
}
else
{
var depthGen = generatorMessage.Generator as MarketDepthGenerator;
if (depthGen != null)
{
if (generatorMessage.IsSubscribe)
{
_depthGenerators.Add(generatorMessage.SecurityId, depthGen);
}
else
{
_depthGenerators.Remove(generatorMessage.SecurityId);
}
}
else
{
var olGen = generatorMessage.Generator as OrderLogGenerator;
if (olGen != null)
{
if (generatorMessage.IsSubscribe)
{
_orderLogGenerators.Add(generatorMessage.SecurityId, olGen);
}
else
{
_orderLogGenerators.Remove(generatorMessage.SecurityId);
}
}
else
{
throw new InvalidOperationException();
}
}
}
return;
}
var security = SecurityProvider.LookupById(message.SecurityId.SecurityCode + "@" + message.SecurityId.BoardCode);
if (security == null)
{
RaiseMarketDataMessage(message, new InvalidOperationException(LocalizedStrings.Str704Params.Put(message.SecurityId)));
return;
}
if (TryGetGenerator(message) != null)
{
RaiseMarketDataMessage(message, null);
return;
}
if (StorageRegistry == null)
{
RaiseMarketDataMessage(message, new InvalidOperationException(LocalizedStrings.Str1117Params.Put(message.DataType, message.SecurityId)));
return;
}
Exception error = null;
switch (message.DataType)
{
case MarketDataTypes.Level1:
{
if (message.IsSubscribe)
{
BasketStorage.InnerStorages.Add(StorageRegistry.GetLevel1MessageStorage(security, Drive, StorageFormat));
BasketStorage.InnerStorages.Add(new InMemoryMarketDataStorage <ClearingMessage>(date => new[]
{
new ClearingMessage
{
LocalTime = date.Date + security.Board.ExpiryTime,
SecurityId = message.SecurityId,
ClearMarketDepth = true
}
}));
}
else
{
RemoveStorage <IMarketDataStorage <Level1ChangeMessage> >(security, MessageTypes.Level1Change, message.Arg);
RemoveStorage <InMemoryMarketDataStorage <ClearingMessage> >(security, ExtendedMessageTypes.Clearing, message.Arg);
}
break;
}
case MarketDataTypes.MarketDepth:
{
if (message.IsSubscribe)
{
BasketStorage.InnerStorages.Add((IMarketDataStorage <QuoteChangeMessage>)StorageRegistry.GetMarketDepthStorage(security, Drive, StorageFormat));
}
else
{
RemoveStorage <IMarketDataStorage <QuoteChangeMessage> >(security, MessageTypes.QuoteChange, message.Arg);
}
break;
}
case MarketDataTypes.Trades:
{
if (message.IsSubscribe)
{
BasketStorage.InnerStorages.Add((IMarketDataStorage <ExecutionMessage>)StorageRegistry.GetTradeStorage(security, Drive, StorageFormat));
}
else
{
RemoveStorage <IMarketDataStorage <ExecutionMessage> >(security, MessageTypes.Execution, message.Arg);
}
break;
}
case MarketDataTypes.OrderLog:
{
if (message.IsSubscribe)
{
BasketStorage.InnerStorages.Add((IMarketDataStorage <ExecutionMessage>)StorageRegistry.GetOrderLogStorage(security, Drive, StorageFormat));
}
else
{
RemoveStorage <IMarketDataStorage <ExecutionMessage> >(security, MessageTypes.Execution, message.Arg);
}
break;
}
case MarketDataTypes.CandleTimeFrame:
case MarketDataTypes.CandleTick:
case MarketDataTypes.CandleVolume:
case MarketDataTypes.CandleRange:
case MarketDataTypes.CandlePnF:
case MarketDataTypes.CandleRenko:
{
Type candleMessageType;
MessageTypes msgType;
switch (message.DataType)
{
case MarketDataTypes.CandleTimeFrame:
msgType = MessageTypes.CandleTimeFrame;
candleMessageType = typeof(TimeFrameCandleMessage);
break;
case MarketDataTypes.CandleTick:
msgType = MessageTypes.CandleTick;
candleMessageType = typeof(TickCandleMessage);
break;
case MarketDataTypes.CandleVolume:
msgType = MessageTypes.CandleVolume;
candleMessageType = typeof(VolumeCandleMessage);
break;
case MarketDataTypes.CandleRange:
msgType = MessageTypes.CandleRange;
candleMessageType = typeof(RangeCandleMessage);
break;
case MarketDataTypes.CandlePnF:
msgType = MessageTypes.CandlePnF;
candleMessageType = typeof(PnFCandleMessage);
break;
case MarketDataTypes.CandleRenko:
msgType = MessageTypes.CandleRenko;
candleMessageType = typeof(RenkoCandleMessage);
break;
default:
throw new InvalidOperationException();
}
if (message.IsSubscribe)
{
BasketStorage.InnerStorages.Add(StorageRegistry.GetCandleMessageStorage(candleMessageType, security, message.Arg, Drive, StorageFormat));
}
else
{
RemoveStorage <IMarketDataStorage <CandleMessage> >(security, msgType, message.Arg);
}
break;
}
default:
error = new InvalidOperationException(LocalizedStrings.Str1118Params.Put(message.DataType));
break;
}
RaiseMarketDataMessage(message, error);
}
