242 lines
11 KiB
C#
242 lines
11 KiB
C#
using KLHZ.Trader.Core.Contracts.Messaging.Interfaces;
|
|
using KLHZ.Trader.Core.DataLayer;
|
|
using KLHZ.Trader.Core.Exchange.Extentions;
|
|
using KLHZ.Trader.Core.Exchange.Models.AssetsAccounting;
|
|
using KLHZ.Trader.Core.Exchange.Models.Configs;
|
|
using Microsoft.EntityFrameworkCore;
|
|
using Microsoft.Extensions.Logging;
|
|
using Microsoft.Extensions.Options;
|
|
using System.Collections.Concurrent;
|
|
using Tinkoff.InvestApi;
|
|
using Tinkoff.InvestApi.V1;
|
|
using Asset = KLHZ.Trader.Core.Exchange.Models.AssetsAccounting.Asset;
|
|
using AssetType = KLHZ.Trader.Core.Exchange.Models.AssetsAccounting.AssetType;
|
|
|
|
namespace KLHZ.Trader.Core.Exchange.Services
|
|
{
|
|
//todo перенести сюда весь кэш и всю работу по сохранению данных.
|
|
public class TradeDataProvider
|
|
{
|
|
private readonly InvestApiClient _investApiClient;
|
|
private readonly IDbContextFactory<TraderDbContext> _dbContextFactory;
|
|
private readonly ILogger<ManagedAccount> _logger;
|
|
private readonly IDataBus _dataBus;
|
|
private readonly string[] _managedAccountsNamePatterns = [];
|
|
private readonly string[] _instrumentsFigis = [];
|
|
|
|
private readonly ConcurrentDictionary<string, InstrumentSettings> _instrumentsSettings = new();
|
|
private readonly ConcurrentDictionary<string, string> _tickersCache = new();
|
|
private readonly ConcurrentDictionary<string, AssetType> _assetTypesCache = new();
|
|
internal readonly ConcurrentDictionary<string, ManagedAccount> Accounts = new();
|
|
public TradeDataProvider(InvestApiClient investApiClient, IOptions<ExchangeConfig> options, IDbContextFactory<TraderDbContext> dbContextFactory, ILogger<ManagedAccount> logger, IDataBus dataBus)
|
|
{
|
|
_investApiClient = investApiClient;
|
|
_dbContextFactory = dbContextFactory;
|
|
_logger = logger;
|
|
_dataBus = dataBus;
|
|
_managedAccountsNamePatterns = options.Value.ManagingAccountNamePatterns.ToArray();
|
|
_instrumentsFigis = options.Value.DataRecievingInstrumentsFigis.ToArray();
|
|
|
|
|
|
foreach (var lev in options.Value.InstrumentsSettings)
|
|
{
|
|
_instrumentsSettings.TryAdd(lev.Figi, lev);
|
|
}
|
|
}
|
|
|
|
public async Task Init()
|
|
{
|
|
var shares = await _investApiClient.Instruments.SharesAsync();
|
|
foreach (var share in shares.Instruments)
|
|
{
|
|
if (_instrumentsFigis.Contains(share.Figi))
|
|
{
|
|
_tickersCache.TryAdd(share.Figi, share.Ticker);
|
|
_assetTypesCache.TryAdd(share.Figi, AssetType.Common);
|
|
}
|
|
}
|
|
var futures = await _investApiClient.Instruments.FuturesAsync();
|
|
foreach (var future in futures.Instruments)
|
|
{
|
|
if (_instrumentsFigis.Contains(future.Figi))
|
|
{
|
|
_tickersCache.TryAdd(future.Figi, future.Ticker);
|
|
_assetTypesCache.TryAdd(future.Figi, AssetType.Common);
|
|
}
|
|
}
|
|
|
|
var accounts = await _investApiClient.GetAccounts(_managedAccountsNamePatterns);
|
|
var accountsList = new List<ManagedAccount>();
|
|
int i = 0;
|
|
foreach (var accountId in accounts)
|
|
{
|
|
var acc = new ManagedAccount(accountId);
|
|
await SyncPortfolio(acc);
|
|
Accounts[accountId] = acc;
|
|
}
|
|
}
|
|
|
|
public string GetTickerByFigi(string figi)
|
|
{
|
|
return _tickersCache.TryGetValue(figi, out var ticker) ? ticker : string.Empty;
|
|
}
|
|
|
|
public AssetType GetAssetTypeByFigi(string figi)
|
|
{
|
|
return _assetTypesCache.TryGetValue(figi, out var t) ? t : AssetType.Unknown;
|
|
}
|
|
|
|
internal async Task SyncPortfolio(ManagedAccount account)
|
|
{
|
|
try
|
|
{
|
|
//await _semaphoreSlim.WaitAsync();
|
|
var portfolio = await _investApiClient.Operations.GetPortfolioAsync(new PortfolioRequest()
|
|
{
|
|
AccountId = account.AccountId,
|
|
});
|
|
|
|
var oldAssets = account.Assets.Keys.ToHashSet();
|
|
using var context = await _dbContextFactory.CreateDbContextAsync();
|
|
context.ChangeTracker.QueryTrackingBehavior = QueryTrackingBehavior.NoTracking;
|
|
|
|
var trades = await context.Trades
|
|
.Where(t => t.AccountId == account.AccountId && t.ArchiveStatus == 0)
|
|
.ToListAsync();
|
|
foreach (var position in portfolio.Positions)
|
|
{
|
|
decimal price = 0;
|
|
var trade = trades.FirstOrDefault(t => t.Figi == position.Figi);
|
|
|
|
if (trade != null)
|
|
{
|
|
trades.Remove(trade);
|
|
price = trade.Price;
|
|
}
|
|
else
|
|
{
|
|
price = position.AveragePositionPrice;
|
|
}
|
|
|
|
#pragma warning disable CS0612 // Тип или член устарел
|
|
var asset = new Models.AssetsAccounting.Asset()
|
|
{
|
|
TradeId = trade?.Id,
|
|
AccountId = account.AccountId,
|
|
Figi = position.Figi,
|
|
Ticker = position.Ticker,
|
|
BoughtAt = trade?.BoughtAt ?? DateTime.UtcNow,
|
|
BoughtPrice = price,
|
|
Type = position.InstrumentType.ParseInstrumentType(),
|
|
Position = position.Quantity > 0 ? PositionType.Long : PositionType.Short,
|
|
BlockedItems = position.BlockedLots,
|
|
Count = position.Quantity,
|
|
CountLots = position.QuantityLots,
|
|
};
|
|
#pragma warning restore CS0612 // Тип или член устарел
|
|
account.Assets.AddOrUpdate(asset.Figi, asset, (k, v) => asset);
|
|
oldAssets.Remove(asset.Figi);
|
|
}
|
|
|
|
account.Total = portfolio.TotalAmountPortfolio;
|
|
account.Balance = portfolio.TotalAmountCurrencies;
|
|
|
|
foreach (var asset in oldAssets)
|
|
{
|
|
account.Assets.TryRemove(asset, out _);
|
|
}
|
|
|
|
var ids = trades.Select(t => t.Id).ToArray();
|
|
await context.Trades
|
|
.Where(t => ids.Contains(t.Id))
|
|
.ExecuteUpdateAsync(t => t.SetProperty(tr => tr.ArchiveStatus, 1));
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.LogError(ex, "Ошибка при синхранизации портфеля счёта {accountId}", account.AccountId);
|
|
}
|
|
finally
|
|
{
|
|
//_semaphoreSlim.Release();
|
|
}
|
|
}
|
|
|
|
public async Task LogDeal(DealResult dealResult)
|
|
{
|
|
using var context = await _dbContextFactory.CreateDbContextAsync();
|
|
context.ChangeTracker.QueryTrackingBehavior = QueryTrackingBehavior.NoTracking;
|
|
var priceCoeff = 1m;
|
|
if (_instrumentsSettings.TryGetValue(dealResult.Figi, out var se))
|
|
{
|
|
priceCoeff = se.PriceToRubConvertationCoefficient;
|
|
}
|
|
var trade = await context.Trades.FirstOrDefaultAsync(t => t.ArchiveStatus == 0 && t.Figi == dealResult.Figi && t.AccountId == dealResult.AccountId);
|
|
if (trade == null)
|
|
{
|
|
var newTrade = new DataLayer.Entities.Trades.Trade()
|
|
{
|
|
AccountId = dealResult.AccountId,
|
|
Figi = dealResult.Figi,
|
|
Ticker = GetTickerByFigi(dealResult.Figi),
|
|
BoughtAt = DateTime.UtcNow,
|
|
Count = dealResult.Count,
|
|
Price = dealResult.Price * priceCoeff,
|
|
Position = dealResult.Count > 0 ? DataLayer.Entities.Trades.Enums.PositionType.Long : DataLayer.Entities.Trades.Enums.PositionType.Short,
|
|
Direction = (DataLayer.Entities.Trades.Enums.TradeDirection)(int)dealResult.Direction,
|
|
Asset = (DataLayer.Entities.Trades.Enums.AssetType)(int)GetAssetTypeByFigi(dealResult.Figi)
|
|
};
|
|
|
|
await context.Trades.AddAsync(newTrade);
|
|
await context.SaveChangesAsync();
|
|
}
|
|
else
|
|
{
|
|
var oldAmount = trade.Price * trade.Count;
|
|
var newAmount = dealResult.Price * priceCoeff * dealResult.Count;
|
|
var oldCount = trade.Count;
|
|
trade.Count = trade.Count + dealResult.Count;
|
|
if (trade.Count != 0 && System.Math.Abs(oldCount) < System.Math.Abs(trade.Count))// Если суммарное количество элементов позиции сокращается - пересчитывать цену не нужно.
|
|
{
|
|
trade.Price = (oldAmount + newAmount) / trade.Count;
|
|
}
|
|
|
|
if (Accounts.TryGetValue(dealResult.AccountId, out var account))
|
|
{
|
|
if (account.Assets.TryGetValue(dealResult.Figi, out var asset))
|
|
{
|
|
if (trade.Count == 0)
|
|
{
|
|
await context.Trades.Where(t => t.Id == trade.Id && t.ArchiveStatus == 0)
|
|
.ExecuteUpdateAsync(t => t.SetProperty(tr => tr.ArchiveStatus, 1));
|
|
account.Assets.TryRemove(dealResult.Figi, out _);
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
context.Trades.Update(trade);
|
|
await context.SaveChangesAsync();
|
|
var newAsset = new Asset()
|
|
{
|
|
AccountId = asset.AccountId,
|
|
Figi = asset.Figi,
|
|
Ticker = asset.Ticker,
|
|
BlockedItems = asset.BlockedItems,
|
|
BoughtAt = DateTime.UtcNow,
|
|
BoughtPrice = trade.Price,
|
|
Count = trade.Count,
|
|
Position = trade.Count > 0 ? PositionType.Long : PositionType.Short,
|
|
Type = asset.Type,
|
|
TradeId = asset.TradeId,
|
|
};
|
|
account.Assets[dealResult.Figi] = newAsset;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
await SyncPortfolio(Accounts[dealResult.AccountId]);
|
|
}
|
|
|
|
}
|
|
}
|