/// <summary>
/// Initializes a new instance of the <see cref="StockSharpExporter"/>.
/// </summary>
/// <param name="security">Security.</param>
/// <param name="arg">The data parameter.</param>
/// <param name="isCancelled">The processor, returning process interruption sign.</param>
/// <param name="storageRegistry">The storage of market data.</param>
/// <param name="drive">Storage.</param>
/// <param name="format">Format type.</param>
public StockSharpExporter(Security security, object arg, Func <int, bool> isCancelled, IStorageRegistry storageRegistry, IMarketDataDrive drive, StorageFormats format)
: base(security, arg, isCancelled, drive.Path)
{
_storageRegistry = storageRegistry ?? throw new ArgumentNullException(nameof(storageRegistry));
_drive = drive ?? throw new ArgumentNullException(nameof(drive));
_format = format;
}
/// <summary>
/// Initializes a new instance of the <see cref="StockSharpExporter"/>.
/// </summary>
/// <param name="dataType">Data type info.</param>
/// <param name="isCancelled">The processor, returning process interruption sign.</param>
/// <param name="storageRegistry">The storage of market data.</param>
/// <param name="drive">Storage.</param>
/// <param name="format">Format type.</param>
public StockSharpExporter(DataType dataType, Func <int, bool> isCancelled, IStorageRegistry storageRegistry, IMarketDataDrive drive, StorageFormats format)
: base(dataType, isCancelled, drive.CheckOnNull().Path)
{
_storageRegistry = storageRegistry ?? throw new ArgumentNullException(nameof(storageRegistry));
_drive = drive ?? throw new ArgumentNullException(nameof(drive));
_format = format;
}
/// <summary>
/// Initializes a new instance of the <see cref="CsvImporter"/>.
/// </summary>
/// <param name="dataType">Data type info.</param>
/// <param name="fields">Importing fields.</param>
/// <param name="entityRegistry">The storage of trade objects.</param>
/// <param name="exchangeInfoProvider">Exchanges and trading boards provider.</param>
/// <param name="drive">The storage. If a value is <see langword="null" />, <see cref="IStorageRegistry.DefaultDrive"/> will be used.</param>
/// <param name="storageFormat">The format type. By default <see cref="StorageFormats.Binary"/> is passed.</param>
public CsvImporter(DataType dataType, IEnumerable <FieldMapping> fields, IEntityRegistry entityRegistry, IExchangeInfoProvider exchangeInfoProvider, IMarketDataDrive drive, StorageFormats storageFormat)
: base(dataType, fields)
{
_entityRegistry = entityRegistry ?? throw new ArgumentNullException(nameof(entityRegistry));
_exchangeInfoProvider = exchangeInfoProvider ?? throw new ArgumentNullException(nameof(exchangeInfoProvider));
_drive = drive;
_storageFormat = storageFormat;
}
/// <summary>
/// Initializes a new instance of the <see cref="CsvImporter"/>.
/// </summary>
/// <param name="dataType">Data type info.</param>
/// <param name="fields">Importing fields.</param>
/// <param name="securityStorage">Securities meta info storage.</param>
/// <param name="exchangeInfoProvider">Exchanges and trading boards provider.</param>
/// <param name="drive">The storage. If a value is <see langword="null" />, <see cref="IStorageRegistry.DefaultDrive"/> will be used.</param>
/// <param name="storageFormat">The format type. By default <see cref="StorageFormats.Binary"/> is passed.</param>
public CsvImporter(DataType dataType, IEnumerable <FieldMapping> fields, ISecurityStorage securityStorage, IExchangeInfoProvider exchangeInfoProvider, IMarketDataDrive drive, StorageFormats storageFormat)
: base(dataType, fields)
{
_securityStorage = securityStorage ?? throw new ArgumentNullException(nameof(securityStorage));
_exchangeInfoProvider = exchangeInfoProvider ?? throw new ArgumentNullException(nameof(exchangeInfoProvider));
_drive = drive;
_storageFormat = storageFormat;
}
private void ConvertDirectory(string path, IStorageRegistry registry, StorageFormats format, ExchangeBoard board)
{
if (!_isStarted)
return;
Directory.GetFiles(path, "*.qsh").ForEach(f => ConvertFile(f, registry, format, board));
Directory.GetDirectories(path).ForEach(d => ConvertDirectory(d, registry, format, board));
}
IMarketDataStorageDrive IMarketDataDrive.GetStorageDrive(SecurityId securityId, Type dataType, object arg, StorageFormats format)
{
var drive = GetDrive();
var storageDrive = drive.GetStorageDrive(securityId, dataType, arg, format);
if (drive == _remoteDrive)
storageDrive = new CacheableMarketDataDrive(storageDrive, _cacheDrive.GetStorageDrive(securityId, dataType, arg, format));
return storageDrive;
}
private void ConvertDirectory(string path, IStorageRegistry registry, StorageFormats format, ExchangeBoard board, string securityLike)
{
if (!_isStarted)
{
return;
}
Directory.GetFiles(path, "*.qsh").ForEach(f => ConvertFile(f, registry, format, board, securityLike));
Directory.GetDirectories(path).ForEach(d => ConvertDirectory(d, registry, format, board, securityLike));
}
/// <summary>
/// Initializes a new instance of the <see cref="StockSharpExporter"/>.
/// </summary>
/// <param name="security">Security.</param>
/// <param name="arg">The data parameter.</param>
/// <param name="isCancelled">The processor, returning export interruption sign.</param>
/// <param name="drive">Storage.</param>
/// <param name="format">Format type.</param>
public StockSharpExporter(Security security, object arg, Func <int, bool> isCancelled, IMarketDataDrive drive, StorageFormats format)
: base(security, arg, isCancelled, drive.Path)
{
if (drive == null)
{
throw new ArgumentNullException(nameof(drive));
}
_drive = drive;
_format = format;
}
public LocalMarketDataStorageDrive(string fileName, string path, StorageFormats format, IMarketDataDrive drive)
{
if (drive == null)
{
throw new ArgumentNullException("drive");
}
if (fileName.IsEmpty())
{
throw new ArgumentNullException("fileName");
}
if (path.IsEmpty())
{
throw new ArgumentNullException("path");
}
_fileName = fileName;
_path = path;
_format = format;
_drive = drive;
_fileNameWithExtension = _fileName + GetExtension(_format);
_datesDict = new Lazy <CachedSynchronizedOrderedDictionary <DateTime, DateTime> >(() =>
{
var retVal = new CachedSynchronizedOrderedDictionary <DateTime, DateTime>();
var datesPath = GetDatesCachePath();
if (File.Exists(datesPath))
{
foreach (var date in LoadDates())
{
retVal.Add(date, date);
}
}
else
{
var dates = InteropHelper
.GetDirectories(_path)
.Where(dir => File.Exists(IOPath.Combine(dir, _fileNameWithExtension)))
.Select(dir => IOPath.GetFileName(dir).ToDateTime(_dateFormat));
foreach (var date in dates)
{
retVal.Add(date, date);
}
SaveDates(retVal.CachedValues);
}
return(retVal);
}).Track();
}
/// <summary>
/// To get the file extension for the format.
/// </summary>
/// <param name="format">Format.</param>
/// <returns>The extension.</returns>
public static string GetExtension(StorageFormats format)
{
switch (format)
{
case StorageFormats.Binary:
return(".bin");
case StorageFormats.Csv:
return(".csv");
default:
throw new ArgumentOutOfRangeException("format");
}
}
/// <summary>
/// Загрузить настройки.
/// </summary>
/// <param name="storage">Хранилище настроек.</param>
public void Load(SettingsStorage storage)
{
if (storage.ContainsKey("Security"))
{
Security = ConfigManager.GetService <IEntityRegistry>().Securities.ReadById(storage.GetValue <string>("Security"));
}
From = storage.GetValue <DateTime>("From");
To = storage.GetValue <DateTime>("To");
if (storage.ContainsKey("Drive"))
{
Drive = DriveCache.Instance.GetDrive(storage.GetValue <string>("Drive"));
}
StorageFormat = storage.GetValue <StorageFormats>("StorageFormat");
}
//private static readonly Version _dateVersion = new Version(1, 0);
public LocalMarketDataStorageDrive(DataType dataType, string path, StorageFormats format, LocalMarketDataDrive drive)
{
_dataType = dataType ?? throw new ArgumentNullException(nameof(dataType));
var fileName = GetFileName(_dataType);
if (path.IsEmpty())
{
throw new ArgumentNullException(nameof(path));
}
_path = path;
_drive = drive ?? throw new ArgumentNullException(nameof(drive));
_fileNameWithExtension = fileName + GetExtension(format);
_datesPath = IOPath.Combine(_path, fileName + format + "Dates.txt");
_datesDict = new Lazy <CachedSynchronizedOrderedDictionary <DateTime, DateTime> >(() =>
{
var retVal = new CachedSynchronizedOrderedDictionary <DateTime, DateTime>();
if (File.Exists(_datesPath))
{
foreach (var date in LoadDates())
{
retVal.Add(date, date);
}
}
else
{
var dates = IOHelper
.GetDirectories(_path)
.Where(dir => File.Exists(IOPath.Combine(dir, _fileNameWithExtension)))
.Select(dir => GetDate(IOPath.GetFileName(dir)));
foreach (var date in dates)
{
retVal.Add(date, date);
}
SaveDates(retVal.CachedValues);
}
return(retVal);
}).Track();
}
public LocalMarketDataStorageDrive(string fileName, string path, StorageFormats format, IMarketDataDrive drive)
{
if (drive == null)
throw new ArgumentNullException("drive");
if (fileName.IsEmpty())
throw new ArgumentNullException("fileName");
if (path.IsEmpty())
throw new ArgumentNullException("path");
_fileName = fileName;
_path = path;
_format = format;
_drive = drive;
_fileNameWithExtension = _fileName + GetExtension(_format);
_datesDict = new Lazy<CachedSynchronizedOrderedDictionary<DateTime, DateTime>>(() =>
{
var retVal = new CachedSynchronizedOrderedDictionary<DateTime, DateTime>();
var datesPath = GetDatesCachePath();
if (File.Exists(datesPath))
{
foreach (var date in LoadDates())
retVal.Add(date, date);
}
else
{
var dates = InteropHelper
.GetDirectories(_path)
.Where(dir => File.Exists(IOPath.Combine(dir, _fileNameWithExtension)))
.Select(dir => IOPath.GetFileName(dir).ToDateTime(_dateFormat));
foreach (var date in dates)
retVal.Add(date, date);
SaveDates(retVal.CachedValues);
}
return retVal;
}).Track();
}
public RemoteStorageDrive(RemoteMarketDataDrive parent, SecurityId securityId, DataType dataType, StorageFormats format)
{
if (securityId.IsDefault())
{
throw new ArgumentNullException(nameof(securityId));
}
if (dataType == null)
{
throw new ArgumentNullException(nameof(dataType));
}
// TODO
//if (drive == null)
// throw new ArgumentNullException(nameof(drive));
_parent = parent ?? throw new ArgumentNullException(nameof(parent));
_securityId = securityId;
_dataType = dataType ?? throw new ArgumentNullException(nameof(dataType));
_format = format;
}
public RemoteStorageDrive(RemoteStorageClient parent, string securityId, Type dataType, object arg, StorageFormats format, IMarketDataDrive drive)
{
if (securityId.IsDefault())
{
throw new ArgumentNullException(nameof(securityId));
}
if (dataType == null)
{
throw new ArgumentNullException(nameof(dataType));
}
// TODO
//if (drive == null)
// throw new ArgumentNullException(nameof(drive));
_parent = parent ?? throw new ArgumentNullException(nameof(parent));
_securityId = securityId;
_dataType = dataType.Name;
_arg = arg.To <string>();
_format = format;
_drive = drive;
}
private void ConvertDirectory(string path, IStorageRegistry registry, StorageFormats format, ExchangeBoard board, string securityLike, bool multithread, Dictionary <SecurityId, IOrderLogMarketDepthBuilder> orderLog2OrderBookBuilders, int orderBookMaxDepth, TimeZoneInfo tz, TimeZoneInfo mz)
{
if (!_isStarted)
{
return;
}
var files = Directory.GetFiles(path, "*.qsh");
if (!multithread)
{
files.ForEach(f => ConvertFile(f, registry, format, board, securityLike, orderLog2OrderBookBuilders, orderBookMaxDepth, tz, mz));
}
else
{
Parallel.ForEach(files, file => ConvertFile(file, registry, format, board, securityLike, orderLog2OrderBookBuilders, orderBookMaxDepth, tz, mz));
}
//пишем имена сконвертированных в деректории файлов qsh, в файл
File.AppendAllLines(_convertedFilesFile, _convertedPerTaskPoolFiles);
_convertedPerTaskPoolFiles.Clear();
Directory.GetDirectories(path).ForEach(d => ConvertDirectory(d, registry, format, board, securityLike, multithread, orderLog2OrderBookBuilders, orderBookMaxDepth, tz, mz));
}
/// <summary>
/// To refresh the table. It is carried out asynchronously.
/// </summary>
/// <param name="storageRegistry">Market-data storage.</param>
/// <param name="security">Security.</param>
/// <param name="format">Data format.</param>
/// <param name="drive">Storage.</param>
public void BeginMakeEntries(IStorageRegistry storageRegistry, Security security, StorageFormats format, IMarketDataDrive drive)
{
if (storageRegistry == null)
throw new ArgumentNullException(nameof(storageRegistry));
lock (_syncObject)
{
_query = new Query(storageRegistry, security, format, drive);
_isChanged = true;
if (_isFlushing)
return;
_isFlushing = true;
ThreadingHelper
.Thread(() => CultureInfo.InvariantCulture.DoInCulture(OnFlush))
.Launch();
}
}
/// <summary>
/// Create storage for <see cref="IMarketDataStorage"/>.
/// </summary>
/// <param name="securityId">Security ID.</param>
/// <param name="dataType">Market data type.</param>
/// <param name="arg">The parameter associated with the <paramref name="dataType" /> type. For example, <see cref="CandleMessage.Arg"/>.</param>
/// <param name="format">Format type.</param>
/// <returns>Storage for <see cref="IMarketDataStorage"/>.</returns>
public override IMarketDataStorageDrive GetStorageDrive(SecurityId securityId, Type dataType, object arg, StorageFormats format)
{
if (securityId.IsDefault())
{
throw new ArgumentNullException("securityId");
}
return(_drives.SafeAdd(Tuple.Create(securityId, dataType, arg, format),
key => new LocalMarketDataStorageDrive(GetFileName(dataType, arg), GetSecurityPath(securityId), format, this)));
}
IMarketDataStorageDrive IMarketDataDrive.GetStorageDrive(SecurityId securityId, Type dataType, object arg, StorageFormats format)
{
var drive = GetDrive();
var storageDrive = drive.GetStorageDrive(securityId, dataType, arg, format);
if (drive == _remoteDrive)
{
storageDrive = new CacheableMarketDataDrive(storageDrive, _cacheDrive.GetStorageDrive(securityId, dataType, arg, format));
}
return(storageDrive);
}
public void Load(SettingsStorage storage)
{
if (storage.ContainsKey(nameof(Security)))
Security = ConfigManager.GetService<IEntityRegistry>().Securities.ReadById(storage.GetValue<string>("Security"));
From = storage.GetValue<DateTime>(nameof(From));
To = storage.GetValue<DateTime>(nameof(To));
if (storage.ContainsKey(nameof(Drive)))
Drive = DriveCache.Instance.GetDrive(storage.GetValue<string>(nameof(Drive)));
StorageFormat = storage.GetValue<StorageFormats>(nameof(StorageFormat));
}
/// <summary>
/// Получить для инструмента доступные типы свечек с параметрами.
/// </summary>
/// <param name="securityId">Идентификатор инструмента.</param>
/// <param name="format">Тип формата.</param>
/// <returns>Доступные типы свечек с параметрами.</returns>
public override IEnumerable<Tuple<Type, object[]>> GetCandleTypes(SecurityId securityId, StorageFormats format)
{
var secPath = GetSecurityPath(securityId);
var ext = GetExtension(format);
return InteropHelper
.GetDirectories(secPath)
.SelectMany(dir => Directory.GetFiles(dir, "candles_*" + ext).Select(IOPath.GetFileNameWithoutExtension))
.Distinct()
.Select(fileName =>
{
var parts = fileName.Split('_');
var type = "{0}.{1}Message, {2}".Put(typeof(CandleMessage).Namespace, parts[1], typeof(CandleMessage).Assembly.FullName).To<Type>();
var value = type.ToCandleArg(parts[2]);
return Tuple.Create(type, value);
})
.GroupBy(t => t.Item1)
.Select(g => Tuple.Create(g.Key, g.Select(t => t.Item2).ToArray()))
.ToArray();
}
IMarketDataStorageDrive IMarketDataDrive.GetStorageDrive(SecurityId securityId, Type dataType, object arg, StorageFormats format)
{
throw new NotSupportedException();
}
/// <summary>
/// Получить хранилище транзакций для заданного инструмента.
/// </summary>
/// <param name="security">Инструмент.</param>
/// <param name="type">Тип данных, информация о которых содержится <see cref="ExecutionMessage"/>.</param>
/// <param name="drive">Хранилище. Если значение равно <see langword="null"/>, то будет использоваться <see cref="IStorageRegistry.DefaultDrive"/>.</param>
/// <param name="format">Тип формата. По-умолчанию передается <see cref="StorageFormats.Binary"/>.</param>
/// <returns>Хранилище транзакций.</returns>
public IMarketDataStorage <ExecutionMessage> GetExecutionStorage(Security security, ExecutionTypes type, IMarketDataDrive drive = null, StorageFormats format = StorageFormats.Binary)
{
if (security == null)
{
throw new ArgumentNullException("security");
}
var securityId = security.ToSecurityId();
return(_executionStorages.SafeAdd(Tuple.Create(securityId, type, (drive ?? DefaultDrive).GetStorageDrive(securityId, typeof(ExecutionMessage), type, format)), key =>
{
var secId = key.Item1;
var mdDrive = key.Item3;
switch (type)
{
case ExecutionTypes.Tick:
{
if (security is ContinuousSecurity)
{
return new ConvertableContinuousSecurityMarketDataStorage <ExecutionMessage, Trade>((ContinuousSecurity)security, null, t => t.ServerTime, t => ToSecurity(t.SecurityId), t => t.ToMessage(), t => t.Time, (s, d) => GetExecutionStorage(s, type, d, format), mdDrive);
}
else if (security is IndexSecurity)
{
return new IndexSecurityMarketDataStorage <ExecutionMessage>((IndexSecurity)security, null, d => ToSecurity(d.SecurityId), (s, d) => GetExecutionStorage(s, type, d, format), mdDrive);
}
else if (security.Board == ExchangeBoard.Associated)
{
return new ConvertableAllSecurityMarketDataStorage <ExecutionMessage, Trade>(security, null, t => t.ServerTime, t => ToSecurity(t.SecurityId), t => t.Time, (s, d) => GetExecutionStorage(s, type, d, format), mdDrive);
}
else
{
IMarketDataSerializer <ExecutionMessage> serializer;
switch (format)
{
case StorageFormats.Binary:
serializer = new TradeSerializer(key.Item1);
break;
case StorageFormats.Csv:
serializer = new CsvMarketDataSerializer <ExecutionMessage>(key.Item1, ExecutionTypes.Tick);
break;
default:
throw new ArgumentOutOfRangeException("format");
}
return new TradeStorage(security, mdDrive, serializer);
}
}
case ExecutionTypes.Order:
case ExecutionTypes.Trade:
return new ExecutionStorage(security, mdDrive, new ExecutionSerializer(secId));
case ExecutionTypes.OrderLog:
{
IMarketDataSerializer <ExecutionMessage> serializer;
switch (format)
{
case StorageFormats.Binary:
serializer = new OrderLogSerializer(secId);
break;
case StorageFormats.Csv:
serializer = new CsvMarketDataSerializer <ExecutionMessage>(secId, ExecutionTypes.OrderLog);
break;
default:
throw new ArgumentOutOfRangeException("format");
}
return new OrderLogStorage(security, mdDrive, serializer);
}
default:
throw new ArgumentOutOfRangeException("type");
}
}));
}
/// <summary>
/// Получить хранилище свечек для заданного инструмента.
/// </summary>
/// <param name="candleMessageType">Тип сообщения свечи.</param>
/// <param name="security">Инструмент.</param>
/// <param name="arg">Параметр свечи.</param>
/// <param name="drive">Хранилище. Если значение равно <see langword="null"/>, то будет использоваться <see cref="IStorageRegistry.DefaultDrive"/>.</param>
/// <param name="format">Тип формата. По-умолчанию передается <see cref="StorageFormats.Binary"/>.</param>
/// <returns>Хранилище свечек.</returns>
public IMarketDataStorage <CandleMessage> GetCandleMessageStorage(Type candleMessageType, Security security, object arg, IMarketDataDrive drive = null, StorageFormats format = StorageFormats.Binary)
{
if (candleMessageType == null)
{
throw new ArgumentNullException("candleMessageType");
}
if (!candleMessageType.IsSubclassOf(typeof(CandleMessage)))
{
throw new ArgumentOutOfRangeException("candleMessageType", candleMessageType, LocalizedStrings.WrongCandleType);
}
if (security == null)
{
throw new ArgumentNullException("security");
}
if (arg.IsNull(true))
{
throw new ArgumentNullException("arg", LocalizedStrings.EmptyCandleArg);
}
var securityId = security.ToSecurityId();
return(_candleStorages.SafeAdd(Tuple.Create(securityId, (drive ?? DefaultDrive).GetStorageDrive(securityId, candleMessageType, arg, format)), key =>
{
if (security is ContinuousSecurity)
{
var type = typeof(CandleContinuousSecurityMarketDataStorage <>).Make(candleMessageType);
Func <CandleMessage, DateTimeOffset> getTime = c => c.OpenTime;
Func <CandleMessage, Security> getSecurity = c => ToSecurity(c.SecurityId);
//Func<Candle, CandleMessage> toMessage = c => c.ToMessage();
//Func<Candle, DateTime> getEntityTime = c => c.OpenTime;
Func <Security, IMarketDataDrive, IMarketDataStorage <CandleMessage> > getStorage = (s, d) => GetCandleMessageStorage(candleMessageType, s, arg, d, format);
return type.CreateInstance <IMarketDataStorage <CandleMessage> >((ContinuousSecurity)security, arg, getTime, getSecurity, getStorage, key.Item2);
}
else if (security is IndexSecurity)
{
return new IndexSecurityMarketDataStorage <CandleMessage>((IndexSecurity)security, arg, c => ToSecurity(c.SecurityId), (s, d) => GetCandleMessageStorage(candleMessageType, s, arg, d, format), key.Item2);
}
else
{
IMarketDataSerializer serializer;
switch (format)
{
case StorageFormats.Binary:
serializer = typeof(CandleSerializer <>).Make(candleMessageType).CreateInstance <IMarketDataSerializer>(security.ToSecurityId(), arg);
break;
case StorageFormats.Csv:
serializer = typeof(CsvMarketDataSerializer <>).Make(candleMessageType).CreateInstance <IMarketDataSerializer>(security.ToSecurityId(), null, arg, null);
break;
default:
throw new ArgumentOutOfRangeException("format");
}
return typeof(CandleStorage <,>).Make(candleMessageType, candleMessageType.ToCandleType()).CreateInstance <IMarketDataStorage <CandleMessage> >(security, arg, key.Item2, serializer);
}
}));
}
/// <summary>
/// Получить хранилище изменений инструмента.
/// </summary>
/// <param name="security">Инструмент.</param>
/// <param name="drive">Хранилище. Если значение равно <see langword="null"/>, то будет использоваться <see cref="IStorageRegistry.DefaultDrive"/>.</param>
/// <param name="format">Тип формата. По-умолчанию передается <see cref="StorageFormats.Binary"/>.</param>
/// <returns>Хранилище изменений инструмента.</returns>
public IMarketDataStorage <Level1ChangeMessage> GetLevel1MessageStorage(Security security, IMarketDataDrive drive = null, StorageFormats format = StorageFormats.Binary)
{
if (security == null)
{
throw new ArgumentNullException("security");
}
var securityId = security.ToSecurityId();
return(_level1Storages.SafeAdd(Tuple.Create(securityId, (drive ?? DefaultDrive).GetStorageDrive(securityId, typeof(Level1ChangeMessage), null, format)), key =>
{
if (security.Board == ExchangeBoard.Associated)
{
return new AllSecurityMarketDataStorage <Level1ChangeMessage>(security, null, md => md.ServerTime, md => ToSecurity(md.SecurityId), (s, d) => GetLevel1MessageStorage(s, d, format), key.Item2);
}
IMarketDataSerializer <Level1ChangeMessage> serializer;
switch (format)
{
case StorageFormats.Binary:
serializer = new Level1Serializer(key.Item1);
break;
case StorageFormats.Csv:
serializer = new CsvMarketDataSerializer <Level1ChangeMessage>(key.Item1);
break;
default:
throw new ArgumentOutOfRangeException("format");
}
return new Level1Storage(security, key.Item2, serializer);
}));
}
/// <summary>
/// Получить хранилище лога заявок для заданного инструмента.
/// </summary>
/// <param name="security">Инструмент.</param>
/// <param name="drive">Хранилище. Если значение равно <see langword="null"/>, то будет использоваться <see cref="IStorageRegistry.DefaultDrive"/>.</param>
/// <param name="format">Тип формата. По-умолчанию передается <see cref="StorageFormats.Binary"/>.</param>
/// <returns>Хранилище лога заявок.</returns>
public IMarketDataStorage <ExecutionMessage> GetOrderLogMessageStorage(Security security, IMarketDataDrive drive = null, StorageFormats format = StorageFormats.Binary)
{
return(GetExecutionStorage(security, ExecutionTypes.OrderLog, drive, format));
}
/// <summary>
/// Получить хранилище стаканов для заданного инструмента.
/// </summary>
/// <param name="security">Инструмент.</param>
/// <param name="drive">Хранилище. Если значение равно <see langword="null"/>, то будет использоваться <see cref="IStorageRegistry.DefaultDrive"/>.</param>
/// <param name="format">Тип формата. По-умолчанию передается <see cref="StorageFormats.Binary"/>.</param>
/// <returns>Хранилище стаканов.</returns>
public IMarketDataStorage <QuoteChangeMessage> GetQuoteMessageStorage(Security security, IMarketDataDrive drive = null, StorageFormats format = StorageFormats.Binary)
{
if (security == null)
{
throw new ArgumentNullException("security");
}
var securityId = security.ToSecurityId();
return(_depthStorages.SafeAdd(Tuple.Create(securityId, (drive ?? DefaultDrive).GetStorageDrive(securityId, typeof(QuoteChangeMessage), null, format)), key =>
{
if (security is ContinuousSecurity)
{
return new ConvertableContinuousSecurityMarketDataStorage <QuoteChangeMessage, MarketDepth>((ContinuousSecurity)security, null, md => md.ServerTime, md => ToSecurity(md.SecurityId), md => md.ToMessage(), md => md.LastChangeTime, (s, d) => GetQuoteMessageStorage(s, d, format), key.Item2);
}
else if (security is IndexSecurity)
{
return new IndexSecurityMarketDataStorage <QuoteChangeMessage>((IndexSecurity)security, null, d => ToSecurity(d.SecurityId), (s, d) => GetQuoteMessageStorage(s, d, format), key.Item2);
}
else if (security.Board == ExchangeBoard.Associated)
{
return new ConvertableAllSecurityMarketDataStorage <QuoteChangeMessage, MarketDepth>(security, null, md => md.ServerTime, md => ToSecurity(md.SecurityId), md => md.LastChangeTime, (s, d) => GetQuoteMessageStorage(s, d, format), key.Item2);
}
else
{
IMarketDataSerializer <QuoteChangeMessage> serializer;
switch (format)
{
case StorageFormats.Binary:
serializer = new QuoteSerializer(key.Item1);
break;
case StorageFormats.Csv:
serializer = new MarketDepthCsvSerializer(key.Item1);
break;
default:
throw new ArgumentOutOfRangeException("format");
}
return new MarketDepthStorage(security, key.Item2, serializer);
}
}));
}
/// <summary>
/// Get all available data types.
/// </summary>
/// <param name="securityId">Instrument identifier.</param>
/// <param name="format">Format type.</param>
/// <returns>Data types.</returns>
public override IEnumerable<DataType> GetAvailableDataTypes(SecurityId securityId, StorageFormats format)
{
var secPath = GetSecurityPath(securityId);
if (!Directory.Exists(secPath))
return Enumerable.Empty<DataType>();
var ext = GetExtension(format);
return InteropHelper
.GetDirectories(secPath)
.SelectMany(dir => Directory.GetFiles(dir, "candles_*" + ext).Select(IOPath.GetFileNameWithoutExtension))
.Distinct()
.Select(GetDataType)
.Where(t => t != null);
}
/// <summary> /// Get all available data types. /// </summary> /// <param name="securityId">Instrument identifier.</param> /// <param name="format">Format type.</param> /// <returns>Data types.</returns> public abstract IEnumerable<DataType> GetAvailableDataTypes(SecurityId securityId, StorageFormats format);
private void Process(IStorageRegistry storageRegistry, Security security, StorageFormats format, IMarketDataDrive drive)
{
this.GuiSync(() =>
{
_visibleEntries.Clear();
Columns.RemoveRange(_candleColumns.Values);
_candleColumns.Values.ForEach(c => FormatRules.Remove(c));
_candleColumns.Clear();
});
if (security == null)
return;
var dict = new Dictionary<DateTime, MarketDataEntry>();
drive = drive ?? storageRegistry.DefaultDrive;
var candles = new Dictionary<string, DataType>();
lock (_syncObject)
{
if (_isChanged)
return;
}
foreach (var tuple in drive.GetAvailableDataTypes(security.ToSecurityId(), format))
{
if (tuple.MessageType.IsCandleMessage())
continue;
var key = tuple.MessageType.Name.Replace("CandleMessage", string.Empty) + " " + tuple.Arg;
candles.Add(key, tuple.Clone());
}
var candleNames = candles.Keys.ToArray();
if (candleNames.Length > 0)
{
this.GuiSync(() =>
{
foreach (var candleName in candleNames)
{
var column = new DataGridTextColumn
{
Header = candleName,
Binding = new Binding
{
Path = new PropertyPath("Candles[{0}]".Put(candleName)),
Converter = new BoolToCheckMarkConverter()
}
};
//var cbElement = new FrameworkElementFactory(typeof(CheckBox));
//var column = new DataGridTemplateColumn
//{
// Header = candle,
// CellStyle = new Style(),
// //SortMemberPath = "Candles[{0}]".Put(key)
// CellTemplate = new DataTemplate(typeof(CheckBox))
// {
// VisualTree = cbElement,
// }
//};
//var bind = new Binding { Path = new PropertyPath("Candles[{0}]".Put(candle)) };
//cbElement.SetBinding(ToggleButton.IsCheckedProperty, bind);
//cbElement.SetValue(IsHitTestVisibleProperty, false);
//cbElement.SetValue(HorizontalAlignmentProperty, HorizontalAlignment.Center);
Columns.Add(column);
_candleColumns.Add(candleName, column);
//ApplyFormatRules(column);
}
//ApplyFormatRules();
});
}
Add(dict, storageRegistry.GetTickMessageStorage(security, drive, format).Dates, candleNames, e => e.IsTick = true);
Add(dict, storageRegistry.GetQuoteMessageStorage(security, drive, format).Dates, candleNames, e => e.IsDepth = true);
Add(dict, storageRegistry.GetLevel1MessageStorage(security, drive, format).Dates, candleNames, e => e.IsLevel1 = true);
Add(dict, storageRegistry.GetOrderLogMessageStorage(security, drive, format).Dates, candleNames, e => e.IsOrderLog = true);
foreach (var c in candleNames)
{
var candleName = c;
lock (_syncObject)
{
if (_isChanged)
return;
}
var tuple = candles[candleName];
Add(dict, storageRegistry.GetCandleMessageStorage(tuple.MessageType, security, tuple.Arg, drive, format).Dates, candleNames, e => e.Candles[candleName] = true);
}
if (dict.Count > 0)
{
// add gaps by working days
var emptyDays = dict.Keys.Min().Range(dict.Keys.Max(), TimeSpan.FromDays(1))
.Where(d => !dict.ContainsKey(d)/* && security.Board.WorkingTime.IsTradeDate(d, true)*/)
.OrderBy()
.ToList();
foreach (var monthGroup in emptyDays.ToArray().GroupBy(d => new DateTime(d.Year, d.Month, 1)))
{
var firstDay = monthGroup.First();
var lastDay = monthGroup.Last();
// whole month do not have any values
if (firstDay.Day == 1 && lastDay.Day == monthGroup.Key.DaysInMonth())
emptyDays.RemoveRange(monthGroup);
}
Add(dict, emptyDays, candleNames, e => { });
}
lock (_syncObject)
{
if (_isChanged)
return;
}
this.GuiSync(RefreshSort);
}
IEnumerable <Tuple <Type, object> > IMarketDataDrive.GetAvailableDataTypes(SecurityId securityId, StorageFormats format)
{
throw new NotSupportedException();
}
/// <summary>
/// Создать хранилище для <see cref="IMarketDataStorage"/>.
/// </summary>
/// <param name="securityId">Идентификатор инструмента.</param>
/// <param name="dataType">Тип маркет-данных.</param>
/// <param name="arg">Параметр, ассоциированный с типом <paramref name="dataType"/>. Например, <see cref="CandleMessage.Arg"/>.</param>
/// <param name="format">Тип формата.</param>
/// <returns>Хранилище для <see cref="IMarketDataStorage"/>.</returns>
public override IMarketDataStorageDrive GetStorageDrive(SecurityId securityId, Type dataType, object arg, StorageFormats format)
{
if (securityId.IsDefault())
throw new ArgumentNullException("securityId");
return _drives.SafeAdd(Tuple.Create(securityId, dataType, arg, format),
key => new LocalMarketDataStorageDrive(CreateFileName(dataType, arg), GetSecurityPath(securityId), format, this));
}
private static string GetExtension(StorageFormats format)
{
switch (format)
{
case StorageFormats.Binary:
return ".bin";
case StorageFormats.Csv:
return ".csv";
default:
throw new ArgumentOutOfRangeException("format");
}
}
/// <summary> /// Get all available data types. /// </summary> /// <param name="securityId">Instrument identifier.</param> /// <param name="format">Format type.</param> /// <returns>Data types.</returns> public abstract IEnumerable<Tuple<Type, object>> GetAvailableDataTypes(SecurityId securityId, StorageFormats format);
private void Process(IStorageRegistry storageRegistry, Security security, StorageFormats format, IMarketDataDrive drive)
{
this.GuiSync(() =>
{
_visibleEntries.Clear();
Columns.RemoveRange(_candleColumns.Values);
_candleColumns.Values.ForEach(c => FormatRules.Remove(c));
_candleColumns.Clear();
});
if (security == null)
{
return;
}
var dict = new Dictionary <DateTime, MarketDataEntry>();
drive = drive ?? storageRegistry.DefaultDrive;
var candles = new Dictionary <string, Tuple <Type, object> >();
lock (_syncObject)
{
if (_isChanged)
{
return;
}
}
foreach (var tuple in drive.GetCandleTypes(security.ToSecurityId(), format))
{
foreach (var arg in tuple.Item2)
{
var key = tuple.Item1.Name.Replace("CandleMessage", string.Empty) + " " + arg;
candles.Add(key, Tuple.Create(tuple.Item1, arg));
}
}
var candleNames = candles.Keys.ToArray();
if (candleNames.Length > 0)
{
this.GuiSync(() =>
{
foreach (var candleName in candleNames)
{
var column = new DataGridTextColumn
{
Header = candleName,
Binding = new Binding
{
Path = new PropertyPath("Candles[{0}]".Put(candleName)),
Converter = new BoolToCheckMarkConverter()
}
};
//var cbElement = new FrameworkElementFactory(typeof(CheckBox));
//var column = new DataGridTemplateColumn
//{
// Header = candle,
// CellStyle = new Style(),
// //SortMemberPath = "Candles[{0}]".Put(key)
// CellTemplate = new DataTemplate(typeof(CheckBox))
// {
// VisualTree = cbElement,
// }
//};
//var bind = new Binding { Path = new PropertyPath("Candles[{0}]".Put(candle)) };
//cbElement.SetBinding(ToggleButton.IsCheckedProperty, bind);
//cbElement.SetValue(IsHitTestVisibleProperty, false);
//cbElement.SetValue(HorizontalAlignmentProperty, HorizontalAlignment.Center);
Columns.Add(column);
_candleColumns.Add(candleName, column);
//ApplyFormatRules(column);
}
//ApplyFormatRules();
});
}
Add(dict, storageRegistry.GetTickMessageStorage(security, drive, format).Dates, candleNames, e => e.IsTick = true);
Add(dict, storageRegistry.GetQuoteMessageStorage(security, drive, format).Dates, candleNames, e => e.IsDepth = true);
Add(dict, storageRegistry.GetLevel1MessageStorage(security, drive, format).Dates, candleNames, e => e.IsLevel1 = true);
Add(dict, storageRegistry.GetOrderLogMessageStorage(security, drive, format).Dates, candleNames, e => e.IsOrderLog = true);
foreach (var c in candleNames)
{
var candleName = c;
lock (_syncObject)
{
if (_isChanged)
{
return;
}
}
var tuple = candles[candleName];
Add(dict, storageRegistry.GetCandleMessageStorage(tuple.Item1, security, tuple.Item2, drive, format).Dates, candleNames, e => e.Candles[candleName] = true);
}
if (dict.Count > 0)
{
// add gaps by working days
var emptyDays = dict.Keys.Min().Range(dict.Keys.Max(), TimeSpan.FromDays(1))
.Where(d => !dict.ContainsKey(d) /* && security.Board.WorkingTime.IsTradeDate(d, true)*/)
.OrderBy()
.ToList();
foreach (var monthGroup in emptyDays.ToArray().GroupBy(d => new DateTime(d.Year, d.Month, 1)))
{
var firstDay = monthGroup.First();
var lastDay = monthGroup.Last();
// whole month do not have any values
if (firstDay.Day == 1 && lastDay.Day == monthGroup.Key.DaysInMonth())
{
emptyDays.RemoveRange(monthGroup);
}
}
Add(dict, emptyDays, candleNames, e => { });
}
lock (_syncObject)
{
if (_isChanged)
{
return;
}
}
this.GuiSync(RefreshSort);
}
public virtual void Load(SettingsStorage storage)
{
if (storage.ContainsKey("SelectedSecurity"))
SelectedSecurity = ConfigManager.GetService<IEntityRegistry>().Securities.ReadById(storage.GetValue<string>("SelectedSecurity"));
From = storage.GetValue<DateTime?>("From");
To = storage.GetValue<DateTime?>("To");
if (storage.ContainsKey("Drive"))
Drive = DriveCache.Instance.GetDrive(storage.GetValue<string>("Drive"));
StorageFormat = storage.GetValue<StorageFormats>("StorageFormat");
}
public OptimizationEmulationConnector(ISecurityProvider securityProvider, IEnumerable <Portfolio> portfolios, IStorageRegistry storageRegistry, StorageFormats format, IMarketDataDrive drive)
: base(securityProvider, portfolios, storageRegistry)
{
Adapter = new BasketEmulationAdapter(this);
Adapter.InnerAdapters.Add(EmulationAdapter);
Adapter.InnerAdapters.Add(HistoryMessageAdapter);
Adapter.LatencyManager = null;
Adapter.CommissionManager = null;
Adapter.PnLManager = null;
Adapter.SlippageManager = null;
HistoryMessageAdapter.StorageFormat = format;
HistoryMessageAdapter.Drive = drive;
}
/// <summary>
/// To get the storage of candles.
/// </summary>
/// <param name="storageRegistry">The external storage.</param>
/// <param name="series">Candles series.</param>
/// <param name="drive">The storage. If a value is <see langword="null" />, <see cref="IStorageRegistry.DefaultDrive"/> will be used.</param>
/// <param name="format">The format type. By default <see cref="StorageFormats.Binary"/> is passed.</param>
/// <returns>The candles storage.</returns>
public static IEntityMarketDataStorage <Candle, CandleMessage> GetCandleStorage(this IStorageRegistry storageRegistry, CandleSeries series, IMarketDataDrive drive = null, StorageFormats format = StorageFormats.Binary)
{
if (series == null)
{
throw new ArgumentNullException(nameof(series));
}
return(storageRegistry.ThrowIfNull().GetCandleStorage(series.CandleType, series.Security, series.Arg, drive, format));
}
/// <summary>
/// Обновить таблицу. Выполняется асинхронно.
/// </summary>
/// <param name="storageRegistry">Хранилище маркет-данных.</param>
/// <param name="security">Инструмент.</param>
/// <param name="format">Формат данных.</param>
/// <param name="drive">Хранилище.</param>
public void BeginMakeEntries(IStorageRegistry storageRegistry, Security security, StorageFormats format, IMarketDataDrive drive)
{
if (storageRegistry == null)
{
throw new ArgumentNullException("storageRegistry");
}
lock (_syncObject)
{
_query = new Query(storageRegistry, security, format, drive);
_isChanged = true;
if (_isFlushing)
{
return;
}
_isFlushing = true;
ThreadingHelper
.Thread(() => CultureInfo.InvariantCulture.DoInCulture(OnFlush))
.Launch();
}
}
private void Process(IStorageRegistry storageRegistry, Security security, StorageFormats format, IMarketDataDrive drive)
{
this.GuiSync(() =>
{
_visibleEntries.Clear();
Columns.RemoveRange(_candleColumns.Values);
_candleColumns.Values.ForEach(c => FormatRules.Remove(c));
_candleColumns.Clear();
});
if (security == null)
return;
var dict = new Dictionary<DateTime, MarketDataEntry>();
drive = drive ?? storageRegistry.DefaultDrive;
var candles = new Dictionary<string, Tuple<Type, object>>();
lock (_syncObject)
{
if (_isChanged)
return;
}
foreach (var tuple in drive.GetCandleTypes(security.ToSecurityId(), format))
{
foreach (var arg in tuple.Item2)
{
var key = tuple.Item1.Name.Replace("CandleMessage", string.Empty) + " " + arg;
candles.Add(key, Tuple.Create(tuple.Item1, arg));
}
}
var candleNames = candles.Keys.ToArray();
if (candleNames.Length > 0)
{
this.GuiSync(() =>
{
foreach (var candleName in candleNames)
{
var column = new DataGridTextColumn
{
Header = candleName,
Binding = new Binding
{
Path = new PropertyPath("Candles[{0}]".Put(candleName)),
Converter = new BoolToCheckMarkConverter()
}
};
//var cbElement = new FrameworkElementFactory(typeof(CheckBox));
//var column = new DataGridTemplateColumn
//{
// Header = candle,
// CellStyle = new Style(),
// //SortMemberPath = "Candles[{0}]".Put(key)
// CellTemplate = new DataTemplate(typeof(CheckBox))
// {
// VisualTree = cbElement,
// }
//};
//var bind = new Binding { Path = new PropertyPath("Candles[{0}]".Put(candle)) };
//cbElement.SetBinding(ToggleButton.IsCheckedProperty, bind);
//cbElement.SetValue(IsHitTestVisibleProperty, false);
//cbElement.SetValue(HorizontalAlignmentProperty, HorizontalAlignment.Center);
Columns.Add(column);
_candleColumns.Add(candleName, column);
//ApplyFormatRules(column);
}
//ApplyFormatRules();
});
}
Add(dict, storageRegistry.GetTickMessageStorage(security, drive, format), candleNames, e => e.IsTick = true);
Add(dict, storageRegistry.GetQuoteMessageStorage(security, drive, format), candleNames, e => e.IsDepth = true);
Add(dict, storageRegistry.GetLevel1MessageStorage(security, drive, format), candleNames, e => e.IsLevel1 = true);
Add(dict, storageRegistry.GetOrderLogMessageStorage(security, drive, format), candleNames, e => e.IsOrderLog = true);
foreach (var c in candleNames)
{
var candleName = c;
lock (_syncObject)
{
if (_isChanged)
return;
}
var tuple = candles[candleName];
Add(dict, storageRegistry.GetCandleMessageStorage(tuple.Item1, security, tuple.Item2, drive, format), candleNames, e => e.Candles[candleName] = true);
}
if (dict.Count > 0)
{
// добавляем рабочие дни, которые отсутствуют в данных
var emptyDays = dict.Keys.Min().Range(dict.Keys.Max(), TimeSpan.FromDays(1))
.Where(d => security.Board.WorkingTime.IsTradeDate(d, true) && !dict.ContainsKey(d));
foreach (var batch in emptyDays.Batch(10))
{
lock (_syncObject)
{
if (_isChanged)
return;
}
TryAddEntries(dict, batch, candleNames, e => { });
}
}
lock (_syncObject)
{
if (_isChanged)
return;
}
this.GuiSync(RefreshSort);
}
IEnumerable <DataType> IMarketDataDrive.GetAvailableDataTypes(SecurityId securityId, StorageFormats format)
{
return(GetDrive().GetAvailableDataTypes(securityId, format));
}
/// <summary>
/// To get the file name by the type of data.
/// </summary>
/// <param name="dataType">Data type.</param>
/// <param name="arg">The parameter associated with the <paramref name="dataType" /> type. For example, <see cref="CandleMessage.Arg"/>.</param>
/// <param name="format">Storage format. If set an extension will be added to the file name.</param>
/// <returns>The file name.</returns>
public static string GetFileName(Type dataType, object arg, StorageFormats? format = null)
{
if (dataType == null)
throw new ArgumentNullException(nameof(dataType));
string fileName;
if (dataType.IsCandleMessage())
fileName = "candles_{0}_{1}".Put(dataType.Name.Replace("Message", string.Empty), TraderHelper.CandleArgToFolderName(arg));
else
{
fileName = _fileNames.TryGetValue(DataType.Create(dataType, arg));
if (fileName == null)
throw new NotSupportedException(LocalizedStrings.Str2872Params.Put(dataType.FullName));
}
if (format != null)
fileName += GetExtension(format.Value);
return fileName;
}
/// <summary>
/// Get all available data types.
/// </summary>
/// <param name="securityId">Instrument identifier.</param>
/// <param name="format">Format type.</param>
/// <returns>Data types.</returns>
public override IEnumerable <Tuple <Type, object> > GetAvailableDataTypes(SecurityId securityId, StorageFormats format)
{
var secPath = GetSecurityPath(securityId);
if (!Directory.Exists(secPath))
{
return(Enumerable.Empty <Tuple <Type, object> >());
}
var ext = GetExtension(format);
return(InteropHelper
.GetDirectories(secPath)
.SelectMany(dir => Directory.GetFiles(dir, "candles_*" + ext).Select(IOPath.GetFileNameWithoutExtension))
.Distinct()
.Select(GetDataType)
.Where(t => t != null));
}
/// <summary> /// Получить для инструмента доступные типы свечек с параметрами. /// </summary> /// <param name="securityId">Идентификатор инструмента.</param> /// <param name="format">Тип формата.</param> /// <returns>Доступные типы свечек с параметрами.</returns> public abstract IEnumerable<Tuple<Type, object[]>> GetCandleTypes(SecurityId securityId, StorageFormats format);
/// <summary> /// Создать хранилище для <see cref="IMarketDataStorage"/>. /// </summary> /// <param name="securityId">Идентификатор инструмента.</param> /// <param name="dataType">Тип маркет-данных.</param> /// <param name="arg">Параметр, ассоциированный с типом <paramref name="dataType"/>. Например, <see cref="CandleMessage.Arg"/>.</param> /// <param name="format">Тип формата.</param> /// <returns>Хранилище для <see cref="IMarketDataStorage"/>.</returns> public abstract IMarketDataStorageDrive GetStorageDrive(SecurityId securityId, Type dataType, object arg, StorageFormats format);
IEnumerable<DataType> IMarketDataDrive.GetAvailableDataTypes(SecurityId securityId, StorageFormats format)
{
return GetDrive().GetAvailableDataTypes(securityId, format);
}
/// <summary>
/// To get the storage of candles.
/// </summary>
/// <typeparam name="TCandle">The candle type.</typeparam>
/// <typeparam name="TArg">The type of candle parameter.</typeparam>
/// <param name="storageRegistry">The external storage.</param>
/// <param name="security">Security.</param>
/// <param name="arg">Candle arg.</param>
/// <param name="drive">The storage. If a value is <see langword="null" />, <see cref="IStorageRegistry.DefaultDrive"/> will be used.</param>
/// <param name="format">The format type. By default <see cref="StorageFormats.Binary"/> is passed.</param>
/// <returns>The candles storage.</returns>
public static IEntityMarketDataStorage <Candle, CandleMessage> GetCandleStorage <TCandle, TArg>(this IStorageRegistry storageRegistry, Security security, TArg arg, IMarketDataDrive drive = null, StorageFormats format = StorageFormats.Binary)
where TCandle : Candle
{
return(storageRegistry.ThrowIfNull().GetCandleStorage(typeof(TCandle), security, arg, drive, format));
}
private void ConvertFile(string fileName, IStorageRegistry registry, StorageFormats format, ExchangeBoard board)
{
if (!_isStarted)
return;
var fileNameKey = format + "_" + fileName;
if (_convertedFiles.Contains(fileNameKey))
return;
_logManager.Application.AddInfoLog("Конвертация файла {0}.", fileName);
const int maxBufCount = 1000;
var data = new Dictionary<Security, Tuple<List<QuoteChangeMessage>, List<ExecutionMessage>, List<Level1ChangeMessage>, List<ExecutionMessage>>>();
using (var qr = QshReader.Open(fileName))
{
var currentDate = qr.CurrentDateTime;
for (var i = 0; i < qr.StreamCount; i++)
{
var stream = (ISecurityStream)qr[i];
var security = GetSecurity(stream.Security, board);
var priceStep = security.PriceStep ?? 1;
var securityId = security.ToSecurityId();
var lastTransactionId = 0L;
var secData = data.SafeAdd(security, key => Tuple.Create(new List<QuoteChangeMessage>(), new List<ExecutionMessage>(), new List<Level1ChangeMessage>(), new List<ExecutionMessage>()));
switch (stream.Type)
{
case StreamType.Stock:
{
((IStockStream)stream).Handler += (key, quotes, spread) =>
{
var quotes2 = quotes.Select(q =>
{
Sides side;
switch (q.Type)
{
case QuoteType.Unknown:
case QuoteType.Free:
case QuoteType.Spread:
throw new ArgumentException(q.Type.ToString());
case QuoteType.Ask:
case QuoteType.BestAsk:
side = Sides.Sell;
break;
case QuoteType.Bid:
case QuoteType.BestBid:
side = Sides.Buy;
break;
default:
throw new ArgumentOutOfRangeException();
}
return new QuoteChange(side, priceStep * q.Price, q.Volume);
}).ToArray();
var md = new QuoteChangeMessage
{
SecurityId = securityId,
ServerTime = currentDate.ApplyTimeZone(TimeHelper.Moscow),
Bids = quotes2.Where(q => q.Side == Sides.Buy),
Asks = quotes2.Where(q => q.Side == Sides.Sell),
};
//if (md.Verify())
//{
secData.Item1.Add(md);
if (secData.Item1.Count > maxBufCount)
{
registry.GetQuoteMessageStorage(security).Save(secData.Item1);
secData.Item1.Clear();
}
//}
//else
// _logManager.Application.AddErrorLog("Стакан для {0} в момент {1} не прошел валидацию. Лучший бид {2}, Лучший офер {3}.", security, qr.CurrentDateTime, md.BestBid, md.BestAsk);
};
break;
}
case StreamType.Deals:
{
((IDealsStream)stream).Handler += deal =>
{
secData.Item2.Add(new ExecutionMessage
{
ExecutionType = ExecutionTypes.Tick,
SecurityId = securityId,
OpenInterest = deal.OI == 0 ? (long?)null : deal.OI,
ServerTime = deal.DateTime.ApplyTimeZone(TimeHelper.Moscow),
Volume = deal.Volume,
TradeId = deal.Id == 0 ? (long?)null : deal.Id,
TradePrice = (decimal)deal.Price,
OriginSide =
deal.Type == DealType.Buy
? Sides.Buy
: (deal.Type == DealType.Sell ? Sides.Sell : (Sides?)null)
});
if (secData.Item2.Count > maxBufCount)
{
registry.GetTickMessageStorage(security).Save(secData.Item2);
secData.Item2.Clear();
}
};
break;
}
case StreamType.OrdLog:
{
((IOrdLogStream)stream).Handler += (key, ol) =>
{
var currTransactionId = ol.DateTime.Ticks;
if (lastTransactionId < currTransactionId)
lastTransactionId = currTransactionId;
else if (lastTransactionId >= currTransactionId)
lastTransactionId++;
var msg = new ExecutionMessage
{
ExecutionType = ExecutionTypes.OrderLog,
SecurityId = securityId,
OpenInterest = ol.OI == 0 ? (long?)null : ol.OI,
OrderId = ol.OrderId,
Price = priceStep * ol.Price,
ServerTime = ol.DateTime.ApplyTimeZone(TimeHelper.Moscow),
Volume = ol.Amount,
Balance = ol.AmountRest,
TradeId = ol.DealId == 0 ? (long?)null : ol.DealId,
TradePrice = ol.DealPrice == 0 ? (decimal?)null : priceStep * ol.DealPrice,
TransactionId = lastTransactionId
};
var status = 0;
if (ol.Flags.Contains(OrdLogFlags.Add))
{
msg.OrderState = OrderStates.Active;
}
else if (ol.Flags.Contains(OrdLogFlags.Fill))
{
msg.OrderState = OrderStates.Done;
}
else if (ol.Flags.Contains(OrdLogFlags.Canceled))
{
msg.OrderState = OrderStates.Done;
status |= 0x200000;
}
else if (ol.Flags.Contains(OrdLogFlags.CanceledGroup))
{
msg.OrderState = OrderStates.Done;
status |= 0x400000;
}
else if (ol.Flags.Contains(OrdLogFlags.Moved))
{
status |= 0x100000;
}
if (ol.Flags.Contains(OrdLogFlags.Buy))
{
msg.Side = Sides.Buy;
}
else if (ol.Flags.Contains(OrdLogFlags.Sell))
{
msg.Side = Sides.Sell;
}
if (ol.Flags.Contains(OrdLogFlags.FillOrKill))
{
msg.TimeInForce = TimeInForce.MatchOrCancel;
status |= 0x00080000;
}
if (ol.Flags.Contains(OrdLogFlags.Quote))
{
msg.TimeInForce = TimeInForce.PutInQueue;
status |= 0x01;
}
if (ol.Flags.Contains(OrdLogFlags.Counter))
{
status |= 0x02;
}
if (ol.Flags.Contains(OrdLogFlags.CrossTrade))
{
status |= 0x20000000;
}
if (ol.Flags.Contains(OrdLogFlags.NonSystem))
{
msg.IsSystem = false;
status |= 0x04;
}
if (ol.Flags.Contains(OrdLogFlags.EndOfTransaction))
{
status |= 0x1000;
}
msg.OrderStatus = (OrderStatus)status;
secData.Item4.Add(msg);
if (secData.Item4.Count > maxBufCount)
{
registry.GetOrderLogMessageStorage(security).Save(secData.Item4);
secData.Item4.Clear();
}
};
break;
}
case StreamType.AuxInfo:
{
((IAuxInfoStream)stream).Handler += (key, info) =>
{
secData.Item3.Add(new Level1ChangeMessage
{
SecurityId = securityId,
ServerTime = info.DateTime.ApplyTimeZone(TimeHelper.Moscow),
}
.TryAdd(Level1Fields.LastTradePrice, priceStep * info.Price)
.TryAdd(Level1Fields.BidsVolume, (decimal)info.BidTotal)
.TryAdd(Level1Fields.AsksVolume, (decimal)info.AskTotal)
.TryAdd(Level1Fields.HighPrice, priceStep * info.HiLimit)
.TryAdd(Level1Fields.LowPrice, priceStep * info.LoLimit)
.TryAdd(Level1Fields.OpenInterest, (decimal)info.OI));
if (secData.Item3.Count > maxBufCount)
{
registry.GetLevel1MessageStorage(security).Save(secData.Item3);
secData.Item3.Clear();
}
};
break;
}
case StreamType.Orders:
case StreamType.Trades:
case StreamType.Messages:
case StreamType.None:
{
continue;
}
default:
throw new ArgumentOutOfRangeException("Неподдерживаемый тип потока {0}.".Put(stream.Type));
}
}
while (qr.CurrentDateTime != DateTime.MaxValue && _isStarted)
qr.Read(true);
}
if (!_isStarted)
return;
foreach (var pair in data)
{
if (pair.Value.Item1.Any())
{
registry.GetQuoteMessageStorage(pair.Key, format: format).Save(pair.Value.Item1);
}
if (pair.Value.Item2.Any())
{
registry.GetTickMessageStorage(pair.Key, format: format).Save(pair.Value.Item2);
}
if (pair.Value.Item3.Any())
{
registry.GetLevel1MessageStorage(pair.Key, format: format).Save(pair.Value.Item3);
}
if (pair.Value.Item4.Any())
{
registry.GetOrderLogMessageStorage(pair.Key, format: format).Save(pair.Value.Item4);
}
}
File.AppendAllLines(_convertedFilesFile, new[] { fileNameKey });
_convertedFiles.Add(fileNameKey);
}
public CandleMessageBuildableStorage(IStorageRegistry registry, SecurityId securityId, TimeSpan timeFrame, IMarketDataDrive drive, StorageFormats format)
{
if (registry == null)
{
throw new ArgumentNullException(nameof(registry));
}
_getStorage = tf => registry.GetCandleMessageStorage(typeof(TimeFrameCandleMessage), securityId, tf, drive, format);
_original = _getStorage(timeFrame);
_timeFrame = timeFrame;
_compressors = GetSmallerTimeFrames().ToDictionary(tf => tf, tf => new BiggerTimeFrameCandleCompressor(new MarketDataMessage
{
SecurityId = securityId,
DataType = MarketDataTypes.CandleTimeFrame,
Arg = timeFrame,
IsSubscribe = true,
}, new TimeFrameCandleBuilder(registry.ExchangeInfoProvider)));
}
IEnumerable<Tuple<Type, object[]>> IMarketDataDrive.GetCandleTypes(SecurityId securityId, StorageFormats format)
{
return GetDrive().GetCandleTypes(securityId, format);
}
