public async Task DeleteAsync(string campaignId, string templateId = null) { var templates = string.IsNullOrEmpty(templateId) ? await _templateStorage.GetDataAsync(GetPartitionKey(campaignId)) : await _templateStorage.GetDataAsync(GetPartitionKey(campaignId), t => t.TemplateId == templateId); if (templates.Any()) { await _templateStorage.DeleteAsync(templates); } // if it's a campaign deletion then delete history too if (string.IsNullOrEmpty(templateId)) { var query = new TableQuery <EmailTemplateHistoryItemEntity>() .Where(TableQuery.GenerateFilterCondition(nameof(EmailTemplateHistoryItemEntity.CampaignId), QueryComparisons.Equal, campaignId)); var entities = new List <EmailTemplateHistoryItemEntity>(); await _templateHistoryStorage.ExecuteAsync(query, chunk => entities.AddRange(chunk)); if (entities.Any()) { await _templateHistoryStorage.DeleteAsync(entities); } } }
public static async Task <StatusReport> Create(INoSQLTableStorage <PriceTableEntity> pricesStorage) { // var assetsStorage = new AzureTableStorage<TableEntity>( // config.AzureTable.StorageConnectionString, // config.AzureTable.AssetsTableName, // new LogToConsole()); // // var assets = await assetsStorage.GetDataAsync(); var now = DateTime.UtcNow; var timePoint = now.AddMinutes(-3); var rowKey = timePoint.ToString("yyyy-MM-dd HH:mm:ss"); var query = new TableQuery <PriceTableEntity>() .Where(TableQuery.GenerateFilterCondition("RowKey", QueryComparisons.GreaterThan, rowKey)); IEnumerable <PriceTableEntity> prices = Enumerable.Empty <PriceTableEntity>(); await pricesStorage.ExecuteAsync(query, result => prices = result); var lastPrices = prices.OrderByDescending(x => x.Timestamp).Take(10); return(new StatusReport() { LastPrices = lastPrices.ToList() }); }
private async Task <IEnumerable <string> > GetPartitionKeys() { var partitionKeys = new ConcurrentBag <string>(); await _tableStorage.ExecuteAsync(new TableQuery <AccountMarginEventReportEntity>(), entity => entity.Select(m => m.PartitionKey).ForEach(pk => partitionKeys.Add(pk))); return(partitionKeys.Distinct()); }
private async Task <IEnumerable <string> > GetPartitionKeys() { var partitionKeys = new ConcurrentBag <string>(); await _tableStorage.ExecuteAsync(new TableQuery <TradingOrderEntity>(), entity => entity.Select(m => m.PartitionKey).ForEach(pk => partitionKeys.Add(pk))); return(partitionKeys); }
public async Task <int> GetActiveOrdersCountAsync(string clientId) { var partitionKey = LimitOrderEntity.ByClientIdActive.GeneratePartitionKey(clientId); var count = 0; await _tableStorage.ExecuteAsync(GetIdsOnly(partitionKey), entities => count += entities.Count()); return(count); }
public static Task WhereAsync <T>(this INoSQLTableStorage <T> tableStorage, string partitionKey, int year, int month, Action <IEnumerable <T> > chunk = null) where T : ITableEntity, new() { var from = new DateTime(year, month, 1); var to = from.AddMonths(1); var rangeQuery = QueryGenerator <T> .BetweenQuery(partitionKey, from, to, ToIntervalOption.ExcludeTo); return(tableStorage.ExecuteAsync(rangeQuery, chunk)); }
private async Task <IEnumerable <string> > GetPartitionKeys() { System.Collections.Concurrent.ConcurrentDictionary <string, byte> partitionKeys = new System.Collections.Concurrent.ConcurrentDictionary <string, byte>(); await _tableStorage.ExecuteAsync(new TableQuery <CheckResultEntity>(), entity => { foreach (var et in entity.Select(m => m.PartitionKey)) { partitionKeys.TryAdd(et, 0); } }); return(partitionKeys.Select(m => m.Key)); }
public async Task DeleteAsync(string campaignId) { var query = new TableQuery <PayInAddressEntity>() .Where(TableQuery.GenerateFilterCondition(nameof(PayInAddressEntity.CampaignId), QueryComparisons.Equal, campaignId)); var entities = new List <PayInAddressEntity>(); await _tableStorage.ExecuteAsync(query, chunk => entities.AddRange(chunk)); if (entities.Any()) { await _tableStorage.DeleteAsync(entities); } }
public async Task <(IEnumerable <IConnectionUrlHistory>, int)> GetPageAsync(int pageNum, int pageSize) { var pk = ConnectionUrlHistory.GeneratePartitionKey(); var filter = TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, pk); var query = new TableQuery <ConnectionUrlHistory>().Where(filter); var pageItems = new List <ConnectionUrlHistory>(); int batchCount = -1; int count = 0; int skip = (pageNum - 1) * pageSize; await _tableStorage.ExecuteAsync( query, batch => { batchCount = batch.Count(); if (count + batchCount < skip) { return; } foreach (var item in batch) { if (count < skip) { ++count; continue; } if (pageItems.Count == pageSize) { return; } pageItems.Add(item); } count += batchCount; }, () => batchCount > 0 && pageItems.Count < pageSize); var totalCount = 10 * pageSize; if (_totalCount.HasValue) { totalCount = _totalCount.Value; } else if (_totalCountTask == null) { Task.Run(async() => { _totalCountTask = CalculateTotalCountAsync(); await _totalCountTask; }); } return(pageItems, totalCount); }
public async Task <IFeedHistory> GetСlosestAvailableAsync(string assetPairId, string priceType, DateTime feedTime) { var rangeQuery = AzureStorageUtils.QueryGenerator <FeedHistoryEntity> .GreaterThanQuery(FeedHistoryEntity.GeneratePartition(assetPairId, priceType), FeedHistoryEntity.GenerateRowKey(feedTime)).Take(1); var resList = new List <FeedHistoryEntity>(); await _tableStorage.ExecuteAsync(rangeQuery, entities => { resList.AddRange(entities); }, () => false); return(resList.Any() ? resList.First().ToDto() : null); }
public async Task <IActionResult> Fix() { var query = new TableQuery <FixMessageTableEntity> { TakeCount = entriesCount }; var logs = new List <FixMessageTableEntity>(entriesCount); await _fixMessagesStorage.ExecuteAsync(query, result => logs.AddRange(result)); var lastEntries = logs.OrderBy(x => x.RowKey); return(View(lastEntries)); }
public async Task <IActionResult> Index() { var query = new TableQuery <LogEntity>() { TakeCount = entriesCount }; var logs = new List <LogEntity>(entriesCount); await _logsStorage.ExecuteAsync(query, result => logs.AddRange(result)); var lastEntries = logs.OrderByDescending(x => x.Timestamp); return(View(lastEntries)); }
public Task ExecuteAsync(TableQuery <TEntity> rangeQuery, Action <IEnumerable <TEntity> > yieldResult, Func <bool> stopCondition = null) { return(_impl.ExecuteAsync(rangeQuery, yieldResult, stopCondition)); }
public Task ExecuteAsync(TableQuery <T> rangeQuery, Action <IEnumerable <T> > yieldResult, Func <bool> stopCondition) => _table.ExecuteAsync(rangeQuery, yieldResult, stopCondition);
public Task ExecuteAsync(TableQuery <TEntity> rangeQuery, Action <IEnumerable <TEntity> > yieldResult, Func <bool> stopCondition = null) => WrapAsync(() => _impl.ExecuteAsync(rangeQuery, yieldResult, stopCondition), nameof(ExecuteAsync), rangeQuery.FilterString);