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);
});
}
private Task ClearDataAsync(List <string> assetPairIds)
{
var keys = new List <string>();
foreach (var assetPairId in assetPairIds)
{
keys.Add(RedisService.GetMarketDataBaseVolumeKey(assetPairId));
keys.Add(RedisService.GetMarketDataQuoteVolumeKey(assetPairId));
keys.Add(RedisService.GetMarketDataPriceKey(assetPairId));
}
return(Task.WhenAll(
_database.KeyDeleteAsync(keys.Select(x => (RedisKey)x).ToArray()),
_tickerWriter.CleanAndKeepMaxPartitions(0),
_priceWriter.CleanAndKeepMaxPartitions(0)
));
}
private void DoTimer(object state)
{
lock (_sync)
{
_timer.Change(Timeout.Infinite, Timeout.Infinite);
}
if (!_isStarted)
{
return;
}
try
{
if (_readAllRecordsCallback != null)
{
var data = _readAllRecordsCallback.Invoke();
foreach (var group in data.GroupBy(e => e.PartitionKey))
{
_writer.CleanAndBulkInsertAsync(group.Key, group).GetAwaiter().GetResult();
}
_log.Info($"Reload MyNoSql table for entity {typeof(TEntity).Name}. Count Record: {data.Count}");
}
if (_maxInCache.HasValue)
{
_writer.CleanAndKeepMaxPartitions(_maxInCache.Value).GetAwaiter().GetResult();
_log.Info($"Clear MyNoSql table for entity {typeof(TEntity).Name}. Max Record: {_maxInCache}");
}
}
catch (Exception ex)
{
_log.Error(ex, $"Cannot refresh data in MyNoSQL table. Entity: {typeof(TEntity).Name}");
}
lock (_sync)
{
if (_isStarted)
{
_timer?.Change(_reloadTimerPeriod, _reloadTimerPeriod);
}
}
}
private async Task <GetDepositAddressResponse> GetBitgoDepositAddressAsync(GetDepositAddressRequest request)
{
try
{
var(bitgoCoin, bitgoWalletId) =
_assetMapper.AssetToBitgoCoinAndWallet(request.BrokerId, request.AssetSymbol);
if (string.IsNullOrEmpty(bitgoWalletId) || string.IsNullOrEmpty(bitgoCoin))
{
_logger.LogError(
"Cannot process GetDepositAddress. Asset do not mapped to bitgo. Request: {jsonText}",
JsonConvert.SerializeObject(request));
return(new GetDepositAddressResponse
{
Error = GetDepositAddressResponse.ErrorCode.AssetDoNotSupported
});
}
Error error = null;
var label = _walletMapper.WalletToBitgoLabel(new JetWalletIdentity
{
BrokerId = request.BrokerId,
ClientId = request.ClientId,
WalletId = request.WalletId
});
await using var ctx = DatabaseContext.Create(_dbContextOptionsBuilder);
var addressEntity = await ctx.Addresses.Where(t =>
t.BrokerId == request.BrokerId && t.ClientId == request.ClientId &&
t.WalletId == request.WalletId && t.Blockchain == request.Blockchain &&
t.AssetSymbol == request.AssetSymbol).FirstOrDefaultAsync();
var address = addressEntity?.Address;
if (string.IsNullOrEmpty(address))
{
(address, error) =
await _depositAddressGeneratorService.GetAddressAsync(bitgoCoin, bitgoWalletId, label);
}
if (string.IsNullOrEmpty(address))
{
var preGeneratedAddresses = (await _generatedAddressDataWriter.GetAsync(
GeneratedDepositAddressEntity.GeneratePartitionKey(request.BrokerId, bitgoCoin,
bitgoWalletId, request.Blockchain)))
.ToList();
if (preGeneratedAddresses.Count > 0)
{
var preGeneratedAddress = preGeneratedAddresses.First();
(address, error) = await _depositAddressGeneratorService.UpdateAddressLabelAsync(bitgoCoin,
bitgoWalletId,
preGeneratedAddress.Address.BitGoAddressId, label);
if (error == null)
{
await _generatedAddressDataWriter.DeleteAsync(preGeneratedAddress.PartitionKey,
preGeneratedAddress.RowKey);
}
}
else
{
(address, error) =
await _depositAddressGeneratorService.GenerateAddressAsync(bitgoCoin, bitgoWalletId, label);
}
}
if (string.IsNullOrEmpty(address) || error != null)
{
_logger.LogError(
"Cannot process GetDepositAddress. Unable to generate address. Request: {jsonText}. Error: {error}",
JsonConvert.SerializeObject(request), error);
return(new GetDepositAddressResponse
{
Error = GetDepositAddressResponse.ErrorCode.AddressNotGenerated
});
}
if (addressEntity == null)
{
await ctx.InsertAsync(new DepositAddressSqlEntity
{
BrokerId = request.BrokerId,
ClientId = request.ClientId,
WalletId = request.WalletId,
Integration = "BitGo",
AssetSymbol = request.AssetSymbol,
Blockchain = request.Blockchain,
Address = address,
CreatedDate = DateTime.Now
});
}
await _addressDataWriter.InsertOrReplaceAsync(DepositAddressEntity.Create(request.WalletId,
request.AssetSymbol, request.Blockchain, address));
await _addressDataWriter.CleanAndKeepMaxPartitions(Program.Settings.MaxClientInCache);
_logger.LogInformation("Handle GetDepositAddress, request: {jsonText}, address: {address}",
JsonConvert.SerializeObject(request), address);
return(new GetDepositAddressResponse
{
Address = address,
Error = GetDepositAddressResponse.ErrorCode.Ok
});
}
catch (Exception ex)
{
_logger.LogError(ex, "Exception on GetDepositAddress with request: {jsonText}",
JsonConvert.SerializeObject(request));
throw;
}
}
public async Task Clear()
{
await _writer.CleanAndKeepMaxPartitions(0);
}
