private void TryAddDrive(IMarketDataDrive drive)
{
if (!Items.Contains(drive))
{
Items.Insert(0, drive);
}
}
/// <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>
/// Load settings.
/// </summary>
/// <param name="storage">Settings storage.</param>
public void Load(SettingsStorage storage)
{
var drives = storage
.GetValue <IEnumerable <SettingsStorage> >(nameof(Drives))
.Select(s => s.LoadEntire <IMarketDataDrive>())
.ToArray();
lock (_drives.SyncRoot)
{
foreach (var drive in drives)
{
_drives.TryAdd(CreatePair(drive.Path), drive);
}
}
if (storage.ContainsKey(nameof(DefaultDrive)))
{
var pair = CreatePair(storage.GetValue <string>(nameof(DefaultDrive)));
if (_drives.TryGetValue(pair, out var drive))
{
DefaultDrive = drive;
}
}
}
/// <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>
/// Обработчик события смены выбранного элемента.
/// </summary>
/// <param name="e">Параметр события.</param>
protected override void OnSelectionChanged(SelectionChangedEventArgs e)
{
var prevDrive = SelectedDrive;
var currDrive = (IMarketDataDrive)SelectedItem;
if (currDrive == _selectPath)
{
var dlg = new VistaFolderBrowserDialog();
if (dlg.ShowDialog(this.GetWindow()) == false)
{
if (prevDrive == null)
{
SelectedIndex = -1;
}
else
{
SelectedIndex = Items.IndexOf(prevDrive);
}
return;
}
SelectedDrive = DriveCache.Instance.GetDrive(dlg.SelectedPath);
TryAddDrive(SelectedDrive);
SelectedItem = SelectedDrive;
}
else
{
SelectedDrive = currDrive;
}
base.OnSelectionChanged(e);
}
/// <summary>
/// Initializes a new instance of the <see cref="CacheableMarketDataDrive"/>.
/// </summary>
/// <param name="drive">The storage (database, file etc.).</param>
/// <param name="sourceDrive">The initial storage of market-data.</param>
/// <param name="cacheDrive">The cache-storage of market-data.</param>
/// <param name="errorHandler">Error handler.</param>
public CacheableMarketDataDrive(IMarketDataDrive drive, IMarketDataStorageDrive sourceDrive, IMarketDataStorageDrive cacheDrive, Action <Exception> errorHandler)
{
_drive = drive ?? throw new ArgumentNullException(nameof(drive));
_sourceDrive = sourceDrive ?? throw new ArgumentNullException(nameof(sourceDrive));
_cacheDrive = cacheDrive ?? throw new ArgumentNullException(nameof(cacheDrive));
_errorHandler = errorHandler ?? throw new ArgumentNullException(nameof(errorHandler));
}
/// <summary>
/// Initializes a new instance of the <see cref="SecurityMarketDataDrive"/>.
/// </summary>
/// <param name="drive">The storage (database, file etc.).</param>
/// <param name="security">Security.</param>
public SecurityMarketDataDrive(IMarketDataDrive drive, Security security)
{
Drive = drive ?? throw new ArgumentNullException(nameof(drive));
Security = security ?? throw new ArgumentNullException(nameof(security));
SecurityId = security.ToSecurityId();
SecurityId.EnsureHashCode();
}
/// <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;
}
public object GetPath(Security security, Type dataType, object arg, DateTime? from, DateTime? to, IMarketDataDrive drive)
{
var fileName = security.GetFileName(dataType, arg, from, to, ExportType);
var dlg = new VistaSaveFileDialog
{
FileName = fileName,
RestoreDirectory = true
};
switch (ExportType)
{
case ExportTypes.Excel:
dlg.Filter = @"xlsx files (*.xlsx)|*.xlsx|All files (*.*)|*.*";
break;
case ExportTypes.Xml:
dlg.Filter = @"xml files (*.xml)|*.xml|All files (*.*)|*.*";
break;
case ExportTypes.Txt:
dlg.Filter = @"text files (*.txt)|*.txt|All files (*.*)|*.*";
break;
case ExportTypes.Sql:
{
var wnd = new DatabaseConnectionWindow();
if (wnd.ShowModal(this))
{
DatabaseConnectionCache.Instance.AddConnection(wnd.Connection);
return wnd.Connection;
}
return null;
}
case ExportTypes.Bin:
{
var wndFolder = new VistaFolderBrowserDialog();
if (drive is LocalMarketDataDrive)
wndFolder.SelectedPath = drive.Path;
return wndFolder.ShowDialog(this.GetWindow()) == true
? DriveCache.Instance.GetDrive(wndFolder.SelectedPath)
: null;
}
default:
{
new MessageBoxBuilder()
.Error()
.Owner(this)
.Text(LocalizedStrings.Str2910Params.Put(ExportType))
.Show();
return null;
}
}
return dlg.ShowDialog(this.GetWindow()) == true ? dlg.FileName : null;
}
public SecurityStorage(StorageRegistry parent, IMarketDataDrive drive)
{
if (drive == null)
throw new ArgumentNullException(nameof(drive));
_parent = parent ?? throw new ArgumentNullException(nameof(parent));
_file = Path.Combine(drive.Path, "instruments.csv");
Load();
}
/// <summary>
/// Initializes a new instance of the <see cref="BinExporter"/>.
/// </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>
public BinExporter(Security security, object arg, Func <int, bool> isCancelled, IMarketDataDrive drive)
: base(security, arg, isCancelled, drive.Path)
{
if (drive == null)
{
throw new ArgumentNullException(nameof(drive));
}
_drive = drive;
}
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>
/// 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;
}
/// <summary>
/// Initializes a new instance of the <see cref="SecurityMarketDataDrive"/>.
/// </summary>
/// <param name="drive">The storage (database, file etc.).</param>
/// <param name="security">Security.</param>
public SecurityMarketDataDrive(IMarketDataDrive drive, Security security)
{
if (drive == null)
{
throw new ArgumentNullException("drive");
}
if (security == null)
{
throw new ArgumentNullException("security");
}
Drive = drive;
Security = security;
}
/// <summary>
/// Initializes a new instance of the <see cref="SecurityMarketDataDrive"/>.
/// </summary>
/// <param name="drive">The storage (database, file etc.).</param>
/// <param name="security">Security.</param>
public SecurityMarketDataDrive(IMarketDataDrive drive, Security security)
{
if (drive == null)
{
throw new ArgumentNullException(nameof(drive));
}
if (security == null)
{
throw new ArgumentNullException(nameof(security));
}
Drive = drive;
Security = security;
SecurityId = security.ToSecurityId();
}
/// <summary>
/// Delete storage.
/// </summary>
/// <param name="drive">Market data storage.</param>
public void DeleteDrive(IMarketDataDrive drive)
{
if (drive == null)
{
throw new ArgumentNullException(nameof(drive));
}
if (drive == DefaultDrive)
{
throw new ArgumentException(nameof(drive));
}
if (_drives.Remove(CreatePair(drive.Path)))
{
DriveDeleted?.Invoke(drive);
}
}
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>
/// Загрузить настройки.
/// </summary>
/// <param name="storage">Хранилище настроек.</param>
public void Load(SettingsStorage storage)
{
var drives = storage
.GetValue <IEnumerable <SettingsStorage> >("Drives")
.Select(s => s.LoadEntire <IMarketDataDrive>())
.ToArray();
lock (_drives.SyncRoot)
{
foreach (var drive in drives)
{
_drives.TryAdd(drive.Path, drive);
}
}
if (storage.ContainsKey("DefaultDrive"))
{
DefaultDrive = _drives[storage.GetValue <string>("DefaultDrive")];
}
}
public RemoteStorageDrive(RemoteStorageClient parent, SecurityId securityId, DataType dataType, 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 ?? throw new ArgumentNullException(nameof(dataType));
_format = format;
_drive = drive;
}
/// <summary>
/// Получить хранилище новостей.
/// </summary>
/// <param name="drive">Хранилище. Если значение равно <see langword="null"/>, то будет использоваться <see cref="DefaultDrive"/>.</param>
/// <param name="format">Тип формата. По-умолчанию передается <see cref="StorageFormats.Binary"/>.</param>
/// <returns>Хранилище новостей.</returns>
public IMarketDataStorage <NewsMessage> GetNewsMessageStorage(IMarketDataDrive drive = null, StorageFormats format = StorageFormats.Binary)
{
return(_newsStorages.SafeAdd((drive ?? DefaultDrive).GetStorageDrive(_newsSecurity.ToSecurityId(), typeof(NewsMessage), null, format), key =>
{
IMarketDataSerializer <NewsMessage> serializer;
switch (format)
{
case StorageFormats.Binary:
serializer = new NewsSerializer();
break;
case StorageFormats.Csv:
serializer = new CsvMarketDataSerializer <NewsMessage>();
break;
default:
throw new ArgumentOutOfRangeException("format");
}
return new NewsStorage(_newsSecurity, serializer, key);
}));
}
private void FlushBuffer(List<dynamic> buffer, IMarketDataDrive drive)
{
var registry = ConfigManager.GetService<IStorageRegistry>();
if (DataType == typeof(NewsMessage))
{
registry.GetNewsMessageStorage(drive, _settings.Format).Save(buffer);
}
else
{
foreach (var typeGroup in buffer.GroupBy(i => i.GetType()))
{
var dataType = (Type)typeGroup.Key;
foreach (var secGroup in typeGroup.GroupBy(i => (SecurityId)i.SecurityId))
{
var secId = secGroup.Key;
var security = InitSecurity(secGroup.Key);
if (dataType.IsSubclassOf(typeof(CandleMessage)))
{
var timeFrame = (TimeSpan)_settings.CandleSettings.Arg;
var candles = secGroup.Cast<CandleMessage>().ToArray();
foreach (var candle in candles)
{
if (candle.CloseTime < candle.OpenTime)
{
// если в файле время закрытия отсутствует
if (candle.CloseTime.Date == candle.CloseTime)
candle.CloseTime = default(DateTimeOffset);
}
else if (candle.CloseTime > candle.OpenTime)
{
// если в файле время открытия отсутствует
if (candle.OpenTime.Date == candle.OpenTime)
{
candle.OpenTime = candle.CloseTime;
//var tfCandle = candle as TimeFrameCandle;
//if (tfCandle != null)
candle.CloseTime += timeFrame;
}
}
}
registry
.GetCandleMessageStorage(dataType, security, timeFrame, drive, _settings.Format)
.Save(candles.OrderBy(c => c.OpenTime));
}
else if (dataType == typeof(TimeQuoteChange))
{
registry
.GetQuoteMessageStorage(security, drive, _settings.Format)
.Save(secGroup
.GroupBy(i => i.Time)
.Select(g => new QuoteChangeMessage
{
SecurityId = secId,
ServerTime = g.Key,
Bids = g.Cast<QuoteChange>().Where(q => q.Side == Sides.Buy).ToArray(),
Asks = g.Cast<QuoteChange>().Where(q => q.Side == Sides.Sell).ToArray(),
})
.OrderBy(md => md.ServerTime));
}
else
{
var storage = registry.GetStorage(security, dataType, ExecutionType, drive, _settings.Format);
if (dataType == typeof(ExecutionMessage))
((IMarketDataStorage<ExecutionMessage>)storage).Save(secGroup.Cast<ExecutionMessage>().OrderBy(m => m.ServerTime));
else if (dataType == typeof(Level1ChangeMessage))
((IMarketDataStorage<Level1ChangeMessage>)storage).Save(secGroup.Cast<Level1ChangeMessage>().OrderBy(m => m.ServerTime));
else
throw new NotSupportedException(LocalizedStrings.Str2872Params.Put(dataType.Name));
}
}
}
}
buffer.Clear();
}
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);
}
/// <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();
}
}
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;
}
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)));
}
private void OnNewDriveCreated(IMarketDataDrive drive)
{
this.GuiAsync(() => TryAddDrive(drive));
}
/// <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);
}));
}
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);
}
/// <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>
/// Получить хранилище свечек для заданного инструмента.
/// </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>
/// 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));
}
/// <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>
/// Initializes a new instance of the <see cref="DriveCache"/>.
/// </summary>
/// <param name="defaultDrive">The storage used by default.</param>
public DriveCache(IMarketDataDrive defaultDrive)
{
DefaultDrive = defaultDrive ?? throw new ArgumentNullException(nameof(defaultDrive));
_drives.Add(CreatePair(DefaultDrive.Path), DefaultDrive);
}
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);
}
/// <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");
}
}));
}
