public async Task <IEnumerable <ICustomerChecksInfo> > GetBatch(int count, string separatingClientId = null) { if (separatingClientId == null) { return(await _tableStorage.WhereAsync(new TableQuery <CustomerChecksInfoEntity>().Take(count))); } var partitionKey = CustomerChecksInfoEntity.GeneratePartitionKey(separatingClientId); var rowKey = CustomerChecksInfoEntity.GenerateRowKey(separatingClientId); var query = new TableQuery <CustomerChecksInfoEntity>() .Where(TableQuery.CombineFilters( TableQuery.GenerateFilterCondition( nameof(ITableEntity.PartitionKey), QueryComparisons.GreaterThanOrEqual, partitionKey), TableOperators.And, TableQuery.GenerateFilterCondition( nameof(ITableEntity.RowKey), QueryComparisons.GreaterThan, rowKey) )).Take(count); return(await _tableStorage.WhereAsync(query)); }
public async Task<IReadOnlyList<IOvernightSwapHistory>> GetAsync(DateTime? @from, DateTime? to) { return (await _tableStorage.WhereAsync(AzureStorageUtils.QueryGenerator<OvernightSwapHistoryEntity>.RowKeyOnly .BetweenQuery(from ?? DateTime.MinValue, to ?? DateTime.MaxValue, ToIntervalOption.IncludeTo))) .OrderByDescending(item => item.Time) .ToList(); }
public async Task <IReadOnlyCollection <AssetRealisedPnL> > GetAsync(string walletId, string assetId, DateTime date, int?limit) { string filterByPk = TableQuery.GenerateFilterCondition(nameof(AssetRealisedPnLEntity.PartitionKey), QueryComparisons.Equal, GetPartitionKey(walletId)); string filterByPeriod = TableQuery.CombineFilters( TableQuery.GenerateFilterCondition(nameof(AssetRealisedPnLEntity.RowKey), QueryComparisons.GreaterThan, GetRowKey(date.Date.AddDays(1))), TableOperators.And, TableQuery.GenerateFilterCondition(nameof(AssetRealisedPnLEntity.RowKey), QueryComparisons.LessThan, GetRowKey(date.Date.AddMilliseconds(-1)))); string filterByAssetId = TableQuery.GenerateFilterCondition(nameof(AssetRealisedPnLEntity.AssetId), QueryComparisons.Equal, assetId); string filter = TableQuery.CombineFilters(filterByPk, TableOperators.And, filterByPeriod); filter = TableQuery.CombineFilters(filter, TableOperators.And, filterByAssetId); var query = new TableQuery <AssetRealisedPnLEntity>().Where(filter).Take(limit); IEnumerable <AssetRealisedPnLEntity> entities = await _storage.WhereAsync(query); return(Mapper.Map <List <AssetRealisedPnL> >(entities)); }
public async Task <IReadOnlyList <IndexHistory> > GetAsync(DateTime from, DateTime to) { var filter = TableQuery.CombineFilters( TableQuery.GenerateFilterCondition(nameof(AzureTableEntity.PartitionKey), QueryComparisons.GreaterThan, GetPartitionKey(to)), TableOperators.And, TableQuery.GenerateFilterCondition(nameof(AzureTableEntity.PartitionKey), QueryComparisons.LessThanOrEqual, GetPartitionKey(from))); var query = new TableQuery <IndexHistoryEntity>().Where(filter); var models = await _storage.WhereAsync(query); var domain = models.OrderBy(x => x.Time) .Select(x => new IndexHistory( x.Value, Mapper.Map <AssetMarketCap[]>(x.MarketCaps), x.Weights, new List <TickPrice>(), new List <AssetPrice>(), x.MiddlePrices, x.Time, Mapper.Map <AssetSettings[]>(x.AssetsSettings))) .ToList(); return(domain); }
public async Task <IEnumerable <ICashOutRequest> > GetHistoryRecordsAsync(DateTime @from, DateTime to) { to = to.Date.AddDays(1); var partitionKey = CashOutAttemptEntity.HistoryRecords.GeneratePartition(); return(await _tableStorage.WhereAsync(partitionKey, from, to, ToIntervalOption.ExcludeTo)); }
public async Task <IReadOnlyList <IAccountBalanceChange> > GetAsync(string accountId, DateTime? @from = null, DateTime?to = null, AccountBalanceChangeReasonType?reasonType = null, bool filterByTradingDay = false) { return((await _tableStorage.WhereAsync(accountId, from ?? DateTime.MinValue, to?.Date.AddDays(1) ?? DateTime.MaxValue, ToIntervalOption.IncludeTo, x => reasonType == null || x.ReasonType == reasonType.ToString())) .OrderByDescending(item => item.ChangeTimestamp).ToList()); }
public static Task <IEnumerable <T> > WhereAsync <T>(this INoSQLTableStorage <T> tableStorage, string partitionKey, DateTime from, DateTime to, ToIntervalOption intervalOption, Func <T, bool> filter = null, bool includeTime = false) where T : ITableEntity, new() { var rangeQuery = QueryGenerator <T> .BetweenQuery(partitionKey, from, to, intervalOption, includeTime); return(filter == null ? tableStorage.WhereAsync(rangeQuery) : tableStorage.WhereAsync(rangeQuery, filter)); }
public async Task <IEnumerable <IClientRegulation> > GetByRegulationIdAsync(string regulationId) { string rowKeyFilter = TableQuery .GenerateFilterCondition(nameof(ClientRegulationEntity.RowKey), QueryComparisons.Equal, GetRowKey(regulationId)); var query = new TableQuery <ClientRegulationEntity>().Where(rowKeyFilter); return(await _tableStorage.WhereAsync(query)); }
// TODO: Need refactoring public async Task <IInvoice> GetAsync(string invoiceId) { string filter = TableQuery .GenerateFilterCondition(nameof(InvoiceEntity.RowKey), QueryComparisons.Equal, GetRowKey(invoiceId)); var query = new TableQuery <InvoiceEntity>().Where(filter); IEnumerable <InvoiceEntity> entities = await _storage.WhereAsync(query); return(Mapper.Map <Invoice>(entities.FirstOrDefault())); }
public async Task <MarketOrder> GetByIdAsync(string marketOrderId) { string filter = TableQuery.GenerateFilterCondition(nameof(ITableEntity.RowKey), QueryComparisons.Equal, GetRowKey(marketOrderId)); var query = new TableQuery <MarketOrderEntity>().Where(filter); IEnumerable <MarketOrderEntity> entities = await _storage.WhereAsync(query); return(Mapper.Map <MarketOrder>(entities.SingleOrDefault())); }
public static Task <IEnumerable <T> > WhereAsync <T>(this INoSQLTableStorage <T> tableStorage, string partitionKey, int year, int month, Func <T, bool> filter = 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(filter == null ? tableStorage.WhereAsync(rangeQuery) : tableStorage.WhereAsync(rangeQuery, filter)); }
public async Task ProcessItemsFromYesterdayAsync(DateTime start, Func <IEnumerable <FeedHistoryEntity>, Task> batchHandler) { try { var assetPairs = await _assetsService.AssetPairGetAllAsync(); _lastAssetPairIds = assetPairs .Select(i => i.Id) .Where(i => i.IsValidPartitionOrRowKey()) .ToList(); } catch (Exception ex) { _log.WriteWarning(nameof(CandlestiсksRepository), start, ex.Message); } if (_lastAssetPairIds == null || _lastAssetPairIds.Count == 0) { string queryText = GenerateQueryWithoutPartition(start); var query = new TableQuery <FeedHistoryEntity>().Where(queryText); var items = await _storage.WhereAsync(query); await batchHandler(items); } else { foreach (var assetPairId in _lastAssetPairIds) { (string pk1, string pk2) = GetPartiotionsForAssetPair(assetPairId); string queryText = GenerateQueryForPartition(start, pk1); var query = new TableQuery <FeedHistoryEntity>().Where(queryText); var items = await _storage.WhereAsync(query); if (items.Any()) { await batchHandler(items); } queryText = GenerateQueryForPartition(start, pk2); query = new TableQuery <FeedHistoryEntity>().Where(queryText); items = await _storage.WhereAsync(query); if (items.Any()) { await batchHandler(items); } } } }
public async Task <IEnumerable <ICandle> > GetCandlesAsync(CandlePriceType priceType, CandleTimeInterval interval, DateTime from, DateTime to) { if (priceType == CandlePriceType.Unspecified) { throw new ArgumentException(nameof(priceType)); } var query = GetTableQuery(priceType, interval, from, to); var entities = await _tableStorage.WhereAsync(query); var candles = entities .SelectMany(e => e.Candles.Select(ci => ci.ToCandle(_assetPairId, e.PriceType, e.DateTime, interval))); return(candles.Where(c => c.Timestamp >= from && c.Timestamp < to)); }
public async Task <IReadOnlyCollection <InternalOrder> > GetByPeriodAsync(DateTime startDate, DateTime endDate, int limit) { string filter = TableQuery.CombineFilters( TableQuery.GenerateFilterCondition(nameof(AzureTableEntity.PartitionKey), QueryComparisons.GreaterThan, GetPartitionKey(endDate.Date.AddDays(1))), TableOperators.And, TableQuery.GenerateFilterCondition(nameof(AzureTableEntity.PartitionKey), QueryComparisons.LessThan, GetPartitionKey(startDate.Date.AddMilliseconds(-1)))); var query = new TableQuery <InternalOrderEntity>().Where(filter).Take(limit); IEnumerable <InternalOrderEntity> entities = await _storage.WhereAsync(query); return(Mapper.Map <List <InternalOrder> >(entities)); }
public async Task <IReadOnlyCollection <BalanceOperation> > GetAsync(DateTime startDate, DateTime endDate, int limit, string assetId, BalanceOperationType balanceOperationType) { string filter = TableQuery.CombineFilters( TableQuery.GenerateFilterCondition(nameof(AzureTableEntity.PartitionKey), QueryComparisons.GreaterThan, GetPartitionKey(endDate.Date.AddDays(1))), TableOperators.And, TableQuery.GenerateFilterCondition(nameof(AzureTableEntity.PartitionKey), QueryComparisons.LessThan, GetPartitionKey(startDate.Date.AddMilliseconds(-1)))); if (!string.IsNullOrEmpty(assetId)) { filter = TableQuery.CombineFilters(filter, TableOperators.And, TableQuery.GenerateFilterCondition(nameof(BalanceOperationEntity.AssetId), QueryComparisons.Equal, assetId)); } if (balanceOperationType != BalanceOperationType.None) { filter = TableQuery.CombineFilters(filter, TableOperators.And, TableQuery.GenerateFilterCondition(nameof(BalanceOperationEntity.Type), QueryComparisons.Equal, balanceOperationType.ToString())); } var query = new TableQuery <BalanceOperationEntity>().Where(filter).Take(limit); IEnumerable <BalanceOperationEntity> entities = await _storage.WhereAsync(query); return(Mapper.Map <List <BalanceOperation> >(entities)); }
public async Task <IEnumerable <IAccountMarginEventReport> > GetAsync(DateTime?dtFrom, DateTime?dtTo) { var partitionKeys = await GetPartitionKeys(); return((await _tableStorage.WhereAsync(partitionKeys, dtFrom ?? DateTime.MinValue, dtTo ?? DateTime.MaxValue, ToIntervalOption.IncludeTo)) .OrderByDescending(item => item.EventTime)); }
private static async Task FetchDataAsync <T>( string partitionValue, string filter, int allCount, INoSQLTableStorage <T> storage, List <T> items, ILog log) where T : class, ITableEntity, new() { if (!string.IsNullOrWhiteSpace(partitionValue)) { string partitionFilter = TableQuery.GenerateFilterCondition(_partitionKey, QueryComparisons.Equal, partitionValue); filter = TableQuery.CombineFilters(partitionFilter, TableOperators.And, filter); } var query = new TableQuery <T>().Where(filter); int countBefore = items.Count; var data = await storage.WhereAsync(query); items.AddRange(data); /*if (items.Count - countBefore > 0) * log.WriteInfo( * nameof(BatchHelper), * nameof(BatchGetDataAsync), * $"Fetched batch of {items.Count - countBefore} items. Processed {allCount}.");*/ }
public async Task <IEnumerable <IFeedCandle> > GetCandlesAsync(PriceType priceType, TimeInterval interval, DateTime from, DateTime to) { if (priceType == PriceType.Unspecified) { throw new ArgumentException(nameof(priceType)); } var partitionKey = CandleTableEntity.GeneratePartitionKey(priceType); var rowKeyFrom = CandleTableEntity.GenerateRowKey(from, interval); var rowKeyTo = CandleTableEntity.GenerateRowKey(to, interval); var query = new TableQuery <CandleTableEntity>(); var pkeyFilter = TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, partitionKey); var rowkeyCondFrom = TableQuery.GenerateFilterCondition("RowKey", QueryComparisons.GreaterThanOrEqual, rowKeyFrom); var rowkeyCondTo = TableQuery.GenerateFilterCondition("RowKey", QueryComparisons.LessThanOrEqual, rowKeyTo); var rowkeyFilter = TableQuery.CombineFilters(rowkeyCondFrom, TableOperators.And, rowkeyCondTo); query.FilterString = TableQuery.CombineFilters(pkeyFilter, TableOperators.And, rowkeyFilter); var entities = await _tableStorage.WhereAsync(query); var result = from e in entities select e.Candles.Select(ci => ci.ToCandle(e.PriceType == PriceType.Bid, e.DateTime, interval)); return(result .SelectMany(c => c) .Where(c => c.DateTime >= from && c.DateTime < to)); }
public async Task <IReadOnlyList <IEventHistory> > GetEventHistoryData(DateTime date, string exchange, string assetPair, decimal?delta) { var dateFilter = TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, GeneratePartitionKey(date)); //var timeFilter = TableQuery.CombineFilters( // TableQuery.GenerateFilterCondition("RowKey", QueryComparisons.GreaterThanOrEqual, GenerateRowKey(from)), // TableOperators.And, // TableQuery.GenerateFilterCondition("RowKey", QueryComparisons.LessThanOrEqual, GenerateRowKey(to)) //); //var combinedFilter = TableQuery.CombineFilters(dateFilter, TableOperators.And, timeFilter); var combinedFilter = dateFilter; combinedFilter = !string.IsNullOrWhiteSpace(exchange) ? TableQuery.CombineFilters(combinedFilter, TableOperators.And, TableQuery.GenerateFilterCondition("Exchange", QueryComparisons.Equal, exchange.ToUpperInvariant())) : combinedFilter; combinedFilter = !string.IsNullOrWhiteSpace(assetPair) ? TableQuery.CombineFilters(combinedFilter, TableOperators.And, TableQuery.GenerateFilterCondition("AssetPair", QueryComparisons.Equal, assetPair.ToUpperInvariant())) : combinedFilter; combinedFilter = delta.HasValue ? TableQuery.CombineFilters(combinedFilter, TableOperators.And, TableQuery.GenerateFilterCondition("Delta", QueryComparisons.Equal, delta.Value.ToString(CultureInfo.InvariantCulture))) : combinedFilter; var query = new TableQuery <EventHistoryEntity>().Where(combinedFilter); return((await _storage.WhereAsync(query)).ToArray()); }
public async Task <IEnumerable <IRegistrationLogEvent> > GetAsync(DateTime @from, DateTime to) { var partitionKey = RegistrationLogEventEntity.GeneratePartitionKey(); return (await _tableStorage.WhereAsync(partitionKey, @from.Date, to.Date.AddDays(1), ToIntervalOption.ExcludeTo)); }
public async Task <IReadOnlyCollection <InternalTrade> > GetAsync(DateTime startDate, DateTime endDate, string assetPairId, string oppositeWalletId, int limit) { string filter = TableQuery.CombineFilters( TableQuery.GenerateFilterCondition(nameof(ITableEntity.PartitionKey), QueryComparisons.GreaterThan, GetPartitionKey(endDate.Date.AddDays(1))), TableOperators.And, TableQuery.GenerateFilterCondition(nameof(ITableEntity.PartitionKey), QueryComparisons.LessThan, GetPartitionKey(startDate.Date.AddMilliseconds(-1)))); if (!string.IsNullOrEmpty(assetPairId)) { filter = TableQuery.CombineFilters(filter, TableOperators.And, TableQuery.GenerateFilterCondition(nameof(InternalTradeEntity.AssetPairId), QueryComparisons.Equal, assetPairId)); } if (!string.IsNullOrEmpty(oppositeWalletId)) { filter = TableQuery.CombineFilters(filter, TableOperators.And, TableQuery.GenerateFilterCondition(nameof(InternalTradeEntity.OppositeWalletId), QueryComparisons.Equal, oppositeWalletId)); } var query = new TableQuery <InternalTradeEntity>().Where(filter).Take(limit); IEnumerable <InternalTradeEntity> entities = await _storage.WhereAsync(query); return(Mapper.Map <List <InternalTrade> >(entities)); }
public async Task <IEnumerable <IAuthorizationLogRecord> > GetAsync(string email, DateTime @from, DateTime to) { var partitionKey = AuthorizationLogRecordEntity.GeneratePartitionKey(email); return (await _tableStorage.WhereAsync(partitionKey, @from.Date, to.Date.AddDays(1), ToIntervalOption.ExcludeTo)); }
public static Task <IEnumerable <T> > GetDataRowKeyOnlyAsync <T>(this INoSQLTableStorage <T> tableStorage, string rowKey) where T : ITableEntity, new() { var query = QueryGenerator <T> .RowKeyOnly.GetTableQuery(rowKey); return(tableStorage.WhereAsync(query)); }
public async Task <IEnumerable <ITradingOrder> > GetAsync(DateTime?dtFrom, DateTime?dtTo) { var keys = await GetPartitionKeys(); return((await _tableStorage.WhereAsync(keys, dtFrom ?? DateTime.MinValue, dtTo ?? DateTime.MaxValue, ToIntervalOption.IncludeTo)) .OrderByDescending(item => item.Timestamp)); }
private async Task UpdateIndexes(InventorySnapshotEntity inventorySnapshotEntity) { var existingIndex = await _indexStorage.GetDataAsync(GetIndexPartitionKey(inventorySnapshotEntity.Time), IndexForLastRowKey); if (existingIndex == null || (await _storage.GetDataAsync(existingIndex)).Time < inventorySnapshotEntity.Time) { // Update index for current day, it now must point to this the last received snapshot await _indexStorage.InsertOrReplaceAsync( AzureIndex.Create(GetIndexPartitionKey(inventorySnapshotEntity.Time), IndexForLastRowKey, inventorySnapshotEntity)); } // If we have index entries for any future date, they are now are invalid, we can just remove them, // as they will be reconstructed if needed var filter = TableQuery.GenerateFilterCondition(nameof(AzureIndex.PartitionKey), QueryComparisons.GreaterThan, GetIndexPartitionKey(inventorySnapshotEntity.Time)); var query = new TableQuery <AzureIndex>().Where(filter); var allNowInvalidIndexEntriesFromTheFuture = (await _indexStorage.WhereAsync(query)).ToList(); foreach (var indexEntity in allNowInvalidIndexEntriesFromTheFuture) { await _indexStorage.DeleteAsync(indexEntity); } }
public async Task <IEnumerable <IFeedHistory> > GetLastTenMinutesAskAsync(string assetPairId) { var rangeQuery = AzureStorageUtils.QueryGenerator <FeedHistoryEntity> .GreaterThanQuery(FeedHistoryEntity.GeneratePartition(assetPairId, PriceType.Ask), FeedHistoryEntity.GenerateRowKey(DateTime.UtcNow.AddMinutes(-10))); return((await _tableStorage.WhereAsync(rangeQuery)).Select(x => x.ToDto())); }
public async Task <IReadOnlyList <Order> > GetAllAsync(string walletId, string assetPair, DateTime?timeFrom, DateTime?timeTo, int limit) { var query = new TableQuery <OrderEntity>().Where(BuildQuery(walletId, assetPair, timeFrom, timeTo)).Take(limit); var entities = await _storage.WhereAsync(query); return(Mapper.Map <IReadOnlyList <Order> >(entities)); }
public async Task <IReadOnlyList <IMessageLocalized> > GetAllTranslationByComponentAsync(string componentName) { TableQuery <MessageLocalizedEntity> query = new TableQuery <MessageLocalizedEntity>() .Where(TableQuery.GenerateFilterCondition("Component", QueryComparisons.Equal, "componentName")); var entities = await _tableStorage.WhereAsync(query); return(entities.Cast <IMessageLocalized>().ToList()); }
public async Task <IEnumerable <IOffchainTransfer> > GetTransfersByOrder(string clientId, string orderId) { var query = new TableQuery <OffchainTransferEntity>() .Where(TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, clientId)) .Where(TableQuery.GenerateFilterCondition("OrderId", QueryComparisons.Equal, orderId)); return(await _storage.WhereAsync(query)); }
public async Task <IEnumerable <IRepositoryUpdateHistory> > GetAsyncByInitialCommit(string initialCommit) { string partitionFilter = TableQuery.GenerateFilterCondition(nameof(RepositoryUpdateHistory.PartitionKey), QueryComparisons.Equal, RepositoryUpdateHistory.GeneratePartitionKey()); string repositoryFilter = TableQuery.GenerateFilterCondition(nameof(RepositoryUpdateHistory.InitialCommit), QueryComparisons.Equal, initialCommit); string queryText = TableQuery.CombineFilters(partitionFilter, TableOperators.And, repositoryFilter); var query = new TableQuery <RepositoryUpdateHistory>().Where(queryText); return(await _tableStorage.WhereAsync(query)); }