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)); }