public async Task UpsertSnapshots(List <SnapshotEntity> entities)
{
await using var ctx = DatabaseContext.Create(_dbContextOptionsBuilder);
await ctx.UpsetAsync(entities);
await ctx.SaveChangesAsync();
await _writer.BulkInsertOrReplaceAsync(entities.Select(SnapshotNoSqlEntity.Create));
await _writer.CleanAndKeepMaxPartitions(Program.Settings.MaxCachedSnapshots);
}
private async Task ProcessMessageAsync(CandlesUpdatedEvent message)
{
if (message.Candles == null || !message.Candles.Any())
{
return;
}
var intervalToSkip = new List <CandleTimeInterval>
{
CandleTimeInterval.Unspecified,
CandleTimeInterval.Sec,
CandleTimeInterval.Minute
};
var candlesToStore = message.Candles.Where(x =>
!string.IsNullOrEmpty(x.AssetPairId) && x.IsLatestChange &&
!intervalToSkip.Contains(x.TimeInterval) && x.PriceType != CandlePriceType.Unspecified)
.ToList();
var candles = _mapper.Map <List <CandleEntity> >(candlesToStore);
await _candlesWriter.BulkInsertOrReplaceAsync(candles);
Task.Run(async() =>
{
await _candlesWriter.CleanAndKeepMaxPartitions(0);
});
}
public async Task Update(List <PositionPortfolio> positions)
{
var items = positions
.Where(e => e.IsOpen)
.Select(PositionPortfolioNoSql.Create)
.ToList();
if (items.Any())
{
await _dataWriter.BulkInsertOrReplaceAsync(items);
}
items = positions
.Where(e => !e.IsOpen)
.Select(PositionPortfolioNoSql.Create)
.ToList();
var list = items.Select(e => _dataWriter.DeleteAsync(e.PartitionKey, e.RowKey).AsTask()).ToList();
if (list.Any())
{
await Task.WhenAll(list);
}
}
private async Task ProcessMessageAsync(BalanceMessage message)
{
if (!message.Balances.Any())
{
return;
}
var walletIds = message.Balances.Select(x => x.Id).Distinct().ToList();
await InitBalancesIfNeededAsync(walletIds);
var entities = message.Balances.Select(balance => new BalanceEntity(balance.Id, balance.Asset)
{
CreatedAt = message.Timestamp,
Balance = balance.NewBalance,
Reserved = balance.NewReserved ?? 0
})
.ToList();
await _writer.BulkInsertOrReplaceAsync(entities);
}
private async Task ProcessMessageAsync(ExecutionEvent message)
{
var orders = new List <OrderEntity>();
var trades = new List <TradeEntity>();
foreach (var order in message.Orders)
{
var orderEntity = _mapper.Map <OrderEntity>(order);
orders.Add(orderEntity);
if (order.Trades == null)
{
continue;
}
foreach (var trade in order.Trades)
{
var tradeEntity = _mapper.Map <TradeEntity>(trade);
tradeEntity.AssetPairId = orderEntity.AssetPairId;
tradeEntity.OrderId = orderEntity.Id;
tradeEntity.PartitionKey = orderEntity.WalletId;
tradeEntity.WalletId = orderEntity.WalletId;
trades.Add(tradeEntity);
}
}
await _orderWriter.BulkInsertOrReplaceAsync(orders);
await _tradeWriter.BulkInsertOrReplaceAsync(trades);
Task.Run(async() =>
{
var ordersToRemove = orders
.Where(x => x.Status == OrderStatus.Matched.ToString() ||
x.Status == OrderStatus.Cancelled.ToString() ||
x.Status == OrderStatus.Rejected.ToString()).ToList();
foreach (var order in ordersToRemove)
{
await _orderWriter.DeleteAsync(order.WalletId, order.Id);
}
var walletIds = trades.Select(x => x.WalletId).Distinct().ToList();
foreach (var walletId in walletIds)
{
await _tradeWriter.CleanAndKeepMaxRecords(walletId, 0);
}
});
}
public async Task <OperationResponse> CreateWithdrawalProfile(CreateGroupRequest request)
{
try
{
var groups = await _profileWriter.GetAsync(FeeProfilesNoSqlEntity.GeneratePartitionKey(),
FeeProfilesNoSqlEntity.GenerateRowKey());
var withdrawalList = groups?.Profiles ?? new List <string>();
var depositList = groups?.DepositProfiles ?? new List <string>()
{
FeeProfileConsts.DefaultProfile
};
withdrawalList.Add(request.ProfileId);
await _profileWriter.InsertOrReplaceAsync(FeeProfilesNoSqlEntity.Create(withdrawalList.Distinct().ToList(), depositList));
if (!string.IsNullOrWhiteSpace(request.CloneFromProfileId))
{
var assets =
(await _assetWriter.GetAsync(
AssetFeesNoSqlEntity.GeneratePartitionKey(request.BrokerId, request.CloneFromProfileId)))
.Select(t => t.AssetFees).ToList();
foreach (var asset in assets)
{
asset.ProfileId = request.ProfileId;
}
await _assetWriter.BulkInsertOrReplaceAsync(assets.Select(AssetFeesNoSqlEntity.Create).ToList());
}
return(new OperationResponse()
{
IsSuccess = true
});
}
catch (Exception e)
{
return(new OperationResponse()
{
IsSuccess = false,
ErrorText = e.Message
});
}
}
