private void EnsureInit()
{
if (_refreshTimer != null)
{
return;
}
Refresh();
var subscriptions = Invoke(f => f.GetSubscriptions(SessionId, DateTime.MinValue));
foreach (var subscription in subscriptions)
{
_subscriptions.Add(subscription.Id, subscription);
}
var backtests = Invoke(f => f.GetBacktests(SessionId, DateTime.Today - TimeSpan.FromDays(5), DateTime.UtcNow));
foreach (var backtest in backtests)
{
_backtests.Add(backtest.Id, backtest);
}
_refreshTimer = ThreadingHelper
.Timer(Refresh)
.Interval(TimeSpan.FromMinutes(1), TimeSpan.FromMinutes(1));
}
/// <summary>
/// Подключиться.
/// </summary>
public override void Connect()
{
base.Connect();
var rooms = Invoke(f => f.GetRooms(SessionId));
foreach (var room in rooms)
{
_rooms.Add(room.Id, room);
}
var ids = Invoke(f => f.GetJoinedRooms(SessionId));
_accessedRooms.AddRange(ids);
var joins = Invoke(f => f.GetAvatingJoins(SessionId));
foreach (var id in joins)
{
_avaitingJoins.Add(id, GetJoin(id));
}
joins = Invoke(f => f.GetMyJoins(SessionId));
foreach (var id in joins)
{
_myJoins.Add(id, GetJoin(id));
}
foreach (var roomId in _accessedRooms)
{
Invoke(f => f.Subscribe(SessionId, roomId));
}
}
private void EnsureInit()
{
lock (_syncObject)
{
if (_refreshTimer != null)
{
return;
}
var processSubscriptions = true;
_refreshTimer = ThreadingHelper.Timer(() =>
{
lock (_syncObject)
{
if (_isProcessing)
{
return;
}
_isProcessing = true;
}
try
{
Refresh();
if (processSubscriptions)
{
var subscriptions = Invoke(f => f.GetSubscriptions2(SessionId, DateTime.MinValue));
foreach (var subscription in subscriptions)
{
_subscriptions.Add(subscription.Id, subscription);
}
//var backtests = Invoke(f => f.GetBacktests(SessionId, DateTime.Today - TimeSpan.FromDays(5), DateTime.UtcNow));
//foreach (var backtest in backtests)
//{
// _backtests.Add(backtest.Id, backtest);
//}
processSubscriptions = false;
}
}
catch (Exception ex)
{
ex.LogError();
}
finally
{
lock (_syncObject)
_isProcessing = false;
}
}).Interval(TimeSpan.Zero, TimeSpan.FromMinutes(1));
}
}
private void Refresh()
{
var ids = Invoke(f => f.GetStrategies(_lastCheckTime)).ToArray();
foreach (var tuple in ids.Where(t => t.Item2 < 0))
{
var strategy = _strategies.TryGetValue(tuple.Item1);
if (strategy != null)
{
StrategyDeleted?.Invoke(strategy);
}
}
var newIds = new List <long>();
var updatedIds = new List <long>();
foreach (var tuple in ids.Where(t => t.Item2 >= 0))
{
var strategy = _strategies.TryGetValue(tuple.Item1);
if (strategy != null)
{
updatedIds.Add(tuple.Item1);
}
else
{
newIds.Add(tuple.Item1);
}
}
var newStrategies = Invoke(f => f.GetDescription(newIds.ToArray()));
foreach (var newStrategy in newStrategies)
{
_strategies.Add(newStrategy.Id, newStrategy);
StrategyCreated?.Invoke(newStrategy);
}
var updatedStrategies = Invoke(f => f.GetDescription(updatedIds.ToArray()));
foreach (var updatedStrategy in updatedStrategies)
{
var strategy = _strategies[updatedStrategy.Id];
CopyTo(updatedStrategy, strategy);
StrategyUpdated?.Invoke(strategy);
}
_lastCheckTime = DateTime.Now;
}
public Position TryAddPosition(Portfolio portfolio, Security security, string clientCode, string depoName, TPlusLimits?limitType, string description, out bool isNew)
{
isNew = false;
Position position;
lock (_positions.SyncRoot)
{
if (depoName == null)
{
depoName = string.Empty;
}
if (clientCode == null)
{
clientCode = string.Empty;
}
var key = Tuple.Create(portfolio, security, clientCode, depoName, limitType);
if (!_positions.TryGetValue(key, out position))
{
isNew = true;
position = EntityFactory.CreatePosition(portfolio, security);
position.DepoName = depoName;
position.LimitType = limitType;
position.Description = description;
position.ClientCode = clientCode;
_positions.Add(key, position);
}
}
return(position);
}
/// <summary>
/// Initializes a new instance of the <see cref="ExchangeInfoProvider"/>.
/// </summary>
/// <param name="entityRegistry">The storage of trade objects.</param>
public ExchangeInfoProvider(IEntityRegistry entityRegistry)
{
if (entityRegistry == null)
{
throw new ArgumentNullException(nameof(entityRegistry));
}
ExchangeBoard.EnumerateExchanges().ForEach(exchange => _exchanges.Add(exchange.Name, exchange));
ExchangeBoard.EnumerateExchangeBoards().ForEach(board => _boards.Add(board.Code, board));
_entityRegistry = entityRegistry;
var boardCodes = new HashSet <string>();
var boardList = _entityRegistry.ExchangeBoards as ExchangeBoardList;
boardCodes.AddRange(boardList != null ? boardList.GetIds() : _entityRegistry.ExchangeBoards.Select(b => b.Code));
var boards = Boards.Where(b => !boardCodes.Contains(b.Code)).ToArray();
if (boards.Length > 0)
{
boards
.Select(b => b.Exchange)
.Distinct()
.ForEach(Save);
boards
.ForEach(Save);
}
_entityRegistry.Exchanges.ForEach(e => _exchanges[e.Name] = e);
_entityRegistry.ExchangeBoards.ForEach(b => _boards[b.Code] = b);
}
/// <summary>
/// To send data request.
/// </summary>
/// <param name="series">The candles series for which data receiving should be started.</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>
public override void Start(CandleSeries series, DateTimeOffset from, DateTimeOffset to)
{
if (series == null)
{
throw new ArgumentNullException("series");
}
var storage = GetStorage(series);
var range = storage.GetRange(from, to);
if (range == null)
{
return;
}
lock (_series.SyncRoot)
{
if (_series.ContainsKey(series))
{
throw new ArgumentException(LocalizedStrings.Str650Params.Put(series), "series");
}
_series.Add(series, new SeriesInfo(series, range.Min, range.Max, storage));
if (_series.Count == 1)
{
Monitor.Pulse(_series.SyncRoot);
}
}
}
/// <summary>
/// Запросить получение данных.
/// </summary>
/// <param name="series">Серия свечек, для которой необходимо начать получать данные.</param>
/// <param name="from">Начальная дата, с которой необходимо получать данные.</param>
/// <param name="to">Конечная дата, до которой необходимо получать данные.</param>
public override void Start(CandleSeries series, DateTimeOffset from, DateTimeOffset to)
{
if (series == null)
{
throw new ArgumentNullException("series");
}
var values = GetValues(series, from, to);
if (values == null)
{
return;
}
lock (_series.SyncRoot)
{
if (_series.ContainsKey(series))
{
throw new ArgumentException(LocalizedStrings.Str650Params.Put(series), "series");
}
_series.Add(series, new SeriesInfo(series, values.GetEnumerator()));
if (_series.Count == 1)
{
Monitor.Pulse(_series.SyncRoot);
}
}
}
/// <summary>
/// To upload the file to the site.
/// </summary>
/// <param name="fileName">File name.</param>
/// <param name="body">File body.</param>
/// <param name="isPublic">Is the file available for public.</param>
/// <param name="progress">Progress callback.</param>
/// <param name="cancel">Cancel callback.</param>
/// <returns>File data.</returns>
public FileData Upload(string fileName, byte[] body, bool isPublic, Action <int> progress = null, Func <bool> cancel = null)
{
if (fileName.IsEmpty())
{
throw new ArgumentNullException(nameof(fileName));
}
if (body == null)
{
throw new ArgumentNullException(nameof(body));
}
if (body.Length == 0)
{
throw new ArgumentOutOfRangeException(nameof(body));
}
var operationId = Invoke(f => f.BeginUpload(AuthenticationClient.Instance.SessionId, fileName, isPublic));
var id = Upload(operationId, body, progress, cancel);
var data = new FileData
{
Id = id,
FileName = fileName,
Body = body,
BodyLength = body.Length,
IsPublic = isPublic,
CreationDate = DateTime.UtcNow
};
_cache.Add(id, data);
return(data);
}
/// <summary>
/// Зарегистрировать индикатор. После регистрации данный индикатор начнет обновляться с использованием переданного источника.
/// Если по данному источнику уже есть сохраненные данные, то они будут использованы для инициализации индикатора.
/// Если пара индикатор-источник уже была ранее зарегистрирована, то вернется существующий токен.
/// </summary>
/// <param name="indicator">Индикатор.</param>
/// <param name="source">Источник данных для индикатора.</param>
/// <returns>Токен, который был зарегистрирован.</returns>
public virtual IndicatorToken RegisterIndicator(IIndicator indicator, IIndicatorSource source)
{
lock (_indicatorUsages.SyncRoot)
{
var token = new IndicatorToken(indicator, source);
var inDict = _indicatorUsages.TryGetValue(token);
if (inDict != null)
{
//найден индикатор, увеличим количество ссылок
inDict.Second++;
return(inDict.First);
}
//индикатора нет, добавим
lock (_sources.SyncRoot)
{
var indicators = _sources.SafeAdd(source, key => new IndicatorList(this, key));
token = new IndicatorToken(indicator, indicators.Source)
{
Container = Container
};
_indicatorUsages.Add(token, new RefPair <IndicatorToken, int>(token, 1));
indicators.Add(token); // тут пройдет подписка на события источника и обработка тех значений, которые уже есть в источнике
}
return(token);
}
}
private AlfaTimeFrames(int interval, TimeSpan value)
{
Interval = interval;
_value = value;
_values.Add(value, this);
}
private void ProcessMarketData(MarketDataMessage mdMsg)
{
switch (mdMsg.DataType)
{
case MarketDataTypes.Level1:
{
if (mdMsg.IsSubscribe)
{
_subscribedLevel1.Add(mdMsg.SecurityId);
}
else
{
_subscribedLevel1.Remove(mdMsg.SecurityId);
}
break;
}
case MarketDataTypes.MarketDepth:
{
if (mdMsg.IsSubscribe)
{
_subscribedDepths.Add(mdMsg.SecurityId, mdMsg.MaxDepth ?? MarketDataMessage.DefaultMaxDepth);
}
else
{
_subscribedDepths.Remove(mdMsg.SecurityId);
}
break;
}
case MarketDataTypes.Trades:
{
if (mdMsg.IsSubscribe)
{
_subscribedTicks.Add(mdMsg.SecurityId);
}
else
{
_subscribedTicks.Remove(mdMsg.SecurityId);
}
break;
}
default:
{
SendOutMarketDataNotSupported(mdMsg.TransactionId);
return;
}
}
var reply = (MarketDataMessage)mdMsg.Clone();
reply.OriginalTransactionId = mdMsg.OriginalTransactionId;
SendOutMessage(reply);
}
/// <summary>
/// Create new series tracking.
/// </summary>
/// <param name="transactionId">Request identifier.</param>
/// <param name="series">Candles series.</param>
public void CreateCandleSeries(long transactionId, CandleSeries series)
{
if (transactionId == 0)
{
throw new ArgumentNullException(nameof(transactionId));
}
_holders.Add(transactionId, new CandlesSeriesHolder(series));
}
private SmartComTimeFrames(SmartBarInterval interval, TimeSpan value)
{
Interval = interval;
_value = value;
_intervals.Add(interval, this);
_values.Add(value, this);
}
private AppConfig()
{
var section = ConfigManager.GetSection <HydraSection>();
SafeAdd <CandleElement>(section.Candles, elem => _candles.Add(elem.Type.To <Type>(), elem.Name));
SafeAdd <IndicatorElement>(section.Indicators, elem => _indicators.Add(new IndicatorType(elem.Type.To <Type>(), elem.Painter.IsEmpty() ? null : elem.Painter.To <Type>())));
_indicators.AddRange(_indicators.CopyAndClear().OrderBy(i => i.Name));
}
/// <summary>
/// Initialize the storage.
/// </summary>
public void Init()
{
foreach (var fileName in Directory.GetFiles(_path, "*.csv"))
{
var item = new CsvExtendedInfoStorageItem(this, fileName);
_items.Add(Path.GetFileNameWithoutExtension(fileName), item);
item.Init();
}
}
/// <summary>
/// Add security.
/// </summary>
/// <param name="portfolio">Portfolio.</param>
public void Add(Portfolio portfolio)
{
if (portfolio is null)
{
throw new ArgumentNullException(nameof(portfolio));
}
_inner.Add(portfolio.Name, portfolio);
NewPortfolio?.Invoke(portfolio);
}
private void ProcessMarketData(MarketDataMessage mdMsg)
{
switch (mdMsg.DataType)
{
case MarketDataTypes.Level1:
{
if (mdMsg.IsSubscribe)
{
_subscribedLevel1.Add(mdMsg.SecurityId);
}
else
{
_subscribedLevel1.Remove(mdMsg.SecurityId);
}
break;
}
case MarketDataTypes.MarketDepth:
{
if (mdMsg.IsSubscribe)
{
_subscribedDepths.Add(mdMsg.SecurityId, mdMsg.MaxDepth);
}
else
{
_subscribedDepths.Remove(mdMsg.SecurityId);
}
break;
}
case MarketDataTypes.Trades:
{
if (mdMsg.IsSubscribe)
{
_subscribedTicks.Add(mdMsg.SecurityId);
}
else
{
_subscribedTicks.Remove(mdMsg.SecurityId);
}
break;
}
default:
throw new ArgumentOutOfRangeException("mdMsg", mdMsg.DataType, LocalizedStrings.Str1618);
}
var reply = (MarketDataMessage)mdMsg.Clone();
reply.OriginalTransactionId = mdMsg.OriginalTransactionId;
SendOutMessage(reply);
}
private void OnCandleKindsResponse(CandleKindsResponse response)
{
_candlePeriods.Clear();
foreach (var kind in response.Kinds)
{
_candlePeriods.Add(kind.Id, TimeSpan.FromSeconds(kind.Period));
}
CandleTimeFramesInitialized.SafeInvoke();
}
private void EnsureInit()
{
if (_refreshTimer != null)
{
return;
}
Refresh();
var subscriptions = Invoke(f => f.GetSubscriptions(SessionId, DateTime.MinValue));
foreach (var subscription in subscriptions)
{
_subscriptions.Add(subscription.Id, subscription);
}
_refreshTimer = ThreadingHelper
.Timer(Refresh)
.Interval(TimeSpan.FromMinutes(1), TimeSpan.FromMinutes(1));
}
private DriveCache()
{
var svc = ConfigManager.TryGetService <IStorageRegistry>();
if (svc == null)
{
return;
}
DefaultDrive = svc.DefaultDrive;
_drives.Add(DefaultDrive.Path, DefaultDrive);
}
/// <summary>
/// Подключиться.
/// </summary>
public override void Connect()
{
base.Connect();
var ids = Invoke(f => f.GetStrategies(SessionId));
var strategies = Invoke(f => f.GetLiteInfo(SessionId, ids.ToArray()));
foreach (var strategy in strategies)
{
_strategies.Add(strategy.Id, strategy);
}
_subscribedStrategies.AddRange(Invoke(f => f.GetSubscribedStrategies(SessionId)));
}
/// <summary>
/// To upload the file to the site .
/// </summary>
/// <param name="fileName">File name.</param>
/// <param name="body">File body.</param>
/// <param name="isPublic">Is the file available for public.</param>
/// <returns>File ID.</returns>
public long Upload(string fileName, byte[] body, bool isPublic)
{
var id = Invoke(f => f.Upload(AuthenticationClient.Instance.TryGetSession ?? Guid.Empty, fileName, body, isPublic));
_cache.Add(id, new FileData
{
Id = id,
FileName = fileName,
Body = body,
IsPublic = isPublic
});
return(id);
}
private void Chart_OnSubscribeIndicatorElement(ChartIndicatorElement element, CandleSeries series, IIndicator indicator)
{
var chartData = new ChartDrawData();
foreach (var candle in _allCandles.Cache)
{
//if (candle.State != CandleStates.Finished)
// candle.State = CandleStates.Finished;
chartData.Group(candle.OpenTime).Add(element, indicator.Process(candle));
}
Chart.Draw(chartData);
_indicators.Add(element, indicator);
}
/// <inheritdoc />
public FileData Upload(string fileName, byte[] body, bool isPublic, Action <long> progress = null, Func <bool> cancel = null)
{
if (fileName.IsEmpty())
{
throw new ArgumentNullException(nameof(fileName));
}
if (body == null)
{
throw new ArgumentNullException(nameof(body));
}
if (body.Length == 0)
{
throw new ArgumentOutOfRangeException(nameof(body));
}
var hash = body.Md5();
var operationId = Invoke(f => f.BeginUpload2(SessionId, fileName, isPublic, Compression, hash));
var id = Upload(operationId, body, progress, cancel);
if (id == null)
{
return(null);
}
var data = new FileData
{
Id = id.Value,
FileName = fileName,
Body = body,
BodyLength = body.LongLength,
IsPublic = isPublic,
CreationDate = DateTime.UtcNow,
Hash = hash,
};
_cache.Add(id.Value, data);
return(data);
}
internal void ReadItems(List <Exception> errors)
{
if (errors == null)
{
throw new ArgumentNullException(nameof(errors));
}
if (!File.Exists(_fileName))
{
return;
}
CultureInfo.InvariantCulture.DoInCulture(() =>
{
using (var stream = new FileStream(_fileName, FileMode.OpenOrCreate))
{
var reader = new FastCsvReader(stream, Registry.Encoding);
while (reader.NextLine())
{
try
{
var item = Read(reader);
var key = GetNormalizedKey(item);
_items.Add(key, item);
Add(item);
}
catch (Exception ex)
{
if (errors.Count < 10)
{
errors.Add(ex);
}
else
{
break;
}
}
}
}
});
}
private void ReadItems()
{
CultureInfo.InvariantCulture.DoInCulture(() =>
{
using (var stream = new FileStream(_fileName, FileMode.OpenOrCreate))
{
var reader = new FastCsvReader(stream, _encoding);
while (reader.NextLine())
{
var item = Read(reader);
var key = GetKey(item);
_items.Add(key, item);
Add(item);
}
}
});
}
/// <inheritdoc />
public void Save(Portfolio portfolio)
{
if (portfolio is null)
{
throw new ArgumentNullException(nameof(portfolio));
}
var isNew = false;
lock (_portfolios.SyncRoot)
{
if (!_portfolios.ContainsKey(portfolio.Name))
{
isNew = true;
_portfolios.Add(portfolio.Name, portfolio);
}
}
(isNew ? NewPortfolio : PortfolioChanged)?.Invoke(portfolio);
}
/// <inheritdoc />
public void Save(Position position)
{
if (position is null)
{
throw new ArgumentNullException(nameof(position));
}
var key = CreateKey(position);
var isNew = false;
lock (_positions.SyncRoot)
{
if (!_positions.ContainsKey(key))
{
isNew = true;
_positions.Add(key, position);
}
}
(isNew ? NewPosition : PositionChanged)?.Invoke(position);
}
/// <summary>
/// To start backtesing.
/// </summary>
/// <param name="backtest">Backtesting session.</param>
public void StartBacktest(StrategyBacktest backtest)
{
backtest.Id = Invoke(f => f.StartBacktest(SessionId, backtest));
_backtests.Add(backtest.Id, backtest);
_startedBacktests.Add(backtest, 0);
}
