public async Task <IEnumerable <ICashInOutOperation> > GetByChunksAsync(string clientId)
{
var partitionkey = CashInOutOperationEntity.ByClientId.GeneratePartitionKey(clientId);
var result = new List <ICashInOutOperation>();
await _tableStorage.GetDataByChunksAsync(partitionkey, entities =>
result.AddRange(entities)
);
return(result);
}
public async Task <IEnumerable <ITextResource> > GetAllAsync()
{
var result = new List <ITextResource>();
await _tableStorage.GetDataByChunksAsync(entities => result.AddRange(entities));
return(result);
}
public async Task ProcessAllAsync(Func <IEnumerable <IOperationToHashMatch>, Task> processAction)
{
Action <IEnumerable <IOperationToHashMatch> > function = async(items) =>
{
await processAction(items);
};
await _table.GetDataByChunksAsync(OperationToHashMatchEntity.GetPartitionKey(), function);
}
public async Task ProcessHistoricalAsync(string operationId, Func <IEnumerable <IOperationToHashMatch>, Task> processAction)
{
Action <IEnumerable <IOperationToHashMatch> > function = async(items) =>
{
await processAction(items);
};
await _tableHistory.GetDataByChunksAsync(operationId, function);
}
public async Task ProcessAllAsync(Func <IEnumerable <ICoin>, Task> processAction)
{
Func <IEnumerable <CoinEntity>, Task> function = async(items) =>
{
await processAction(items);
};
await _table.GetDataByChunksAsync(function);
}
public async Task ProcessAllAsync(Func <ITransferContract, Task> processAction)
{
await _table.GetDataByChunksAsync(TransferContractEntity.GenerateParitionKey(), async (items) =>
{
foreach (var item in items)
{
await processAction(item);
}
});
}
public async Task ProcessAllAsync(Func <IErc20DepositContract, Task> processAction)
{
await _table.GetDataByChunksAsync(GetParitionKey(), async (items) =>
{
foreach (var item in items)
{
await processAction(item);
}
});
}
public async Task CleanAsync()
{
Func <IEnumerable <IAddressNonce>, Task> func = async(items) =>
{
foreach (var item in items)
{
await _table.DeleteIfExistAsync(AddressNonceEntity.GetPartitionKey(), item.Address);
}
};
await _table.GetDataByChunksAsync(func);
}
public async Task <IReadOnlyList <IDisclaimer> > GetAllAsync()
{
var result = new List <Disclaimer>();
await _storage.GetDataByChunksAsync(chunks =>
{
result.AddRange(Mapper.Map <List <Disclaimer> >(chunks
.Where(x => x.RowKey.IsGuid())));
});
return(result);
}
public async Task <IEnumerable <LimitOrder> > GetLimitOrdersByStatusAsync(OrderStatus orderStatus)
{
var partitionKey = OrderEntity.GeneratePartitionAsAllOrders(orderStatus);
var result = new List <LimitOrder>();
await _tableStorage.GetDataByChunksAsync(partitionKey,
chunk =>
result.AddRange(chunk.Select(orderEntity => orderEntity.GetOrder()).OfType <LimitOrder>()));
return(result);
}
public Task EnumerateBcnCredsByChunksAsync(string assetId, Func <IEnumerable <IBcnCredentialsRecord>, Task> chunks)
{
var partition = FirstGenerationBlockchainWalletEntity.FromBcnClientCredentials.ByAssetAddress.GeneratePartition();
var filter = TableQuery.CombineFilters(
TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, partition),
TableOperators.And,
TableQuery.GenerateFilterCondition("AssetId", QueryComparisons.Equal, assetId));
var query = new TableQuery <FirstGenerationBlockchainWalletEntity.FromBcnClientCredentials>().Where(filter);
return(_bcnClientCredentialsWalletTable.GetDataByChunksAsync(query, chunks));
}
public async Task <Dictionary <string, double> > GetTotalBalancesAsync()
{
var result = new Dictionary <string, double>();
await _tableStorage.GetDataByChunksAsync(entities =>
{
foreach (var walletEntity in entities)
{
foreach (var balances in walletEntity.Get())
{
if (!result.ContainsKey(balances.AssetId))
{
result.Add(balances.AssetId, balances.Balance);
}
else
{
result[balances.AssetId] += balances.Balance;
}
}
}
});
return(result);
}
private const decimal TooBigValue = (long)1 << 60; // 1 * 10^18
public async Task <Dictionary <string, decimal> > GetTotalBalancesAsync()
{
var groupedBalances = new List <Dictionary <string, decimal> >();
await _tableStorage.GetDataByChunksAsync(entities =>
{
var balances = entities
.Where(x => x.AssetId != "TotalBalance" && x.Balance > 0m && x.Balance < TooBigValue)
.GroupBy(g => g.AssetId)
.ToDictionary(d => d.Key, g => g.Sum(wallet => wallet.Balance));
groupedBalances.Add(balances);
});
return(groupedBalances.SelectMany(dict => dict)
.ToLookup(pair => pair.Key, pair => pair.Value)
.ToDictionary(group => group.Key, group => group.Sum()));
}
public async Task <double> CalcTotalAsync()
{
var partitionKey = Lkk2YOrderEntity.GeneratePartitionKey();
var total = 0.0;
await _tableStorage.GetDataByChunksAsync(partitionKey,
chunk => total += chunk.Sum(entity =>
{
AddToCache(entity.Email);
return(entity.UsdAmount);
}));
return(total);
}
public async Task ProcessAllAsync(Func <IBcnCredentialsRecord, Task> processAction)
{
await _tableStorage.GetDataByChunksAsync(async (items) =>
{
foreach (var item in items)
{
try
{
await processAction(item);
}
catch
{
Console.WriteLine("Error while processing");
}
}
});
}
public async Task GetClientsByChunkAsync(Func <IEnumerable <IClientAccount>, Task> chunkCallback)
{
await _clientsTablestorage.GetDataByChunksAsync(async chunk =>
{
var yieldResult = new List <IClientAccount>();
var partitionKey = ClientAccountEntity.GeneratePartitionKey();
foreach (var clientAccount in chunk.Where(item => item.PartitionKey == partitionKey))
{
yieldResult.Add(clientAccount);
}
if (yieldResult.Count > 0)
{
await chunkCallback(yieldResult);
yieldResult.Clear();
}
});
}
public async Task GetDataByChunksAsync()
{
var data11 = new TestEntity(11, "hello", "p1", "r1");
var data12 = new TestEntity(12, "hello", "p1", "r2");
var data13 = new TestEntity(13, "hello", "p1", "r3");
var data21 = new TestEntity(21, "hello", "p2", "r1");
await Storage.InsertAsync(data11);
await Storage.InsertAsync(data12);
await Storage.InsertAsync(data13);
await Storage.InsertAsync(data21);
await Storage.GetDataByChunksAsync("p1", chunk =>
{
Assert.AreEqual(3, chunk.Count());
Assert.AreEqual(3, chunk.Count(x => x.PropertyAsEncrypted == "hello"));
});
}
public Task GetCandlesByChunksAsync(string assetPair, CandlePriceType priceType, DateTime endDate, Func <IEnumerable <IFeedHistory>, Task> readChunkFunc)
{
var partition = FeedHistoryEntity.GeneratePartitionKey(assetPair, priceType);
var filter = TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, partition);
var tableQuery = new TableQuery <FeedHistoryEntity>().Where(filter);
var feedEndDate = endDate.RoundToMinute();
return(_tableStorage.GetDataByChunksAsync(tableQuery, async chunk =>
{
var yieldResult = new List <IFeedHistory>();
foreach (var historyItem in chunk.Where(item => item.DateTime <= feedEndDate))
{
yieldResult.Add(FeedHistory.Create(historyItem));
}
if (yieldResult.Count > 0)
{
await readChunkFunc(yieldResult);
}
}));
}
public async Task <int> GetNumberOfRows(INoSQLTableStorage <TableEntity> tableStorage, int numberOfRetries)
{
var _numberOfRows = 0;
for (int i = numberOfRetries; i > 0; i--)
{
try
{
var tableQuery = new TableQuery <TableEntity>();
await tableStorage.GetDataByChunksAsync(tableQuery.Select(new List <string> {
"PartitionKey"
}), items => { _numberOfRows += items.Count(); });
}
catch (Exception e)
{
await _log.WriteErrorAsync(nameof(AzureTableCheckService), $"Getting number of rows. Table:\"{tableStorage.Name}\"", e);
}
}
return(_numberOfRows);
}
private async Task CalculateTotalCountAsync()
{
if (_totalCountTask != null)
{
return;
}
try
{
var pk = ConnectionUrlHistory.GeneratePartitionKey();
int totalCount = 0;
await _tableStorage.GetDataByChunksAsync(pk, c =>
{
totalCount += c.Count();
});
_totalCount = totalCount;
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
_totalCountTask = null;
}
}
public Task GetDataByChunksAsync(Func <IEnumerable <T>, Task> chunks)
{
return(_storage.GetDataByChunksAsync(Map(chunks)));
}
public Task GetDataByChunksAsync(Func <IEnumerable <TEntity>, Task> chunks)
{
return(_impl.GetDataByChunksAsync(chunks));
}
public Task GetDataByChunksAsync(TableQuery <T> rangeQuery, Func <IEnumerable <T>, Task> chunks) => _table.GetDataByChunksAsync(rangeQuery, chunks);
public Task GetDataByChunksAsync(Func <IEnumerable <TEntity>, Task> chunks) => WrapAsync(() => _impl.GetDataByChunksAsync(chunks), nameof(GetDataByChunksAsync));
public Task GetDataByChunksAsync(Func <IEnumerable <ITransferEvent>, Task> chunk)
{
return(_tableStorage.GetDataByChunksAsync(chunk));
}
public Task GetDataByChunksAsync(Func <IEnumerable <IClientTrade>, Task> chunk)
{
return(_tableStorage.GetDataByChunksAsync(chunk));
}
public async Task GetByChunksAsync(Action <IEnumerable <IPersonalData> > callback)
{
var partitionKey = PersonalDataEntity.GeneratePartitionKey();
await _tableStorage.GetDataByChunksAsync(partitionKey, callback);
}
public Task GetDataByChunksAsync(Func <IEnumerable <TEntity>, Task> chunks) => WrapAsync(() => _impl.GetDataByChunksAsync(chunks), Name, "GetDataByChunksAsync - chunk tasks");
public async Task ProcessByChunksAsync(Func <IEnumerable <IForwardWithdrawal>, Task> processHandler)
{
await _tableStorage.GetDataByChunksAsync(new TableQuery <ForwardWithdrawalEntity>(), processHandler);
}
public Task GetDataByChunksAsync(Func <IEnumerable <ICashInOutOperation>, Task> chunk)
{
return(_tableStorage.GetDataByChunksAsync(chunk));
}
