public async Task AddAsync(SmsProvider provider, string countryCode, SmsDeliveryStatus status) { var entity = await _tableStorage.GetDataAsync(SmsProviderInfoEntity.GeneratePartitionKey(provider), SmsProviderInfoEntity.GenerateRowKey(countryCode)); if (entity == null) { entity = SmsProviderInfoEntity.Create(provider, countryCode, status); await _tableStorage.TryInsertAsync(entity); } else { await _tableStorage.MergeAsync(SmsProviderInfoEntity.GeneratePartitionKey(provider), SmsProviderInfoEntity.GenerateRowKey(countryCode), infoEntity => { switch (status) { case SmsDeliveryStatus.Delivered: infoEntity.DeliveredCount++; break; case SmsDeliveryStatus.Failed: infoEntity.DeliveryFailedCount++; break; case SmsDeliveryStatus.Unknown: infoEntity.UnknownCount++; break; default: throw new ArgumentOutOfRangeException(nameof(status), status, null); } return(infoEntity); }); } }
public static async Task <IEnumerable <T> > GetDataAsync <T>(this INoSQLTableStorage <T> tableStorage, IEnumerable <IAzureIndex> indices, int pieces = 15, Func <T, bool> filter = null) where T : ITableEntity, new() { var idx = indices.ToArray(); if (idx.Length == 0) { return(new T[0]); } var partitionKey = idx.First().PrimaryPartitionKey; var rowKeys = idx.Select(itm => itm.PrimaryRowKey).ToArray(); return(await tableStorage.GetDataAsync(partitionKey, rowKeys, pieces, filter)); }
public async Task <ISupervisorMembership> GetAsync(string employeeId) { AzureIndex index = await _employeeIndexStorage.GetDataAsync( SupervisorMembershipEntity.IndexByEmployee.GeneratePartitionKey(employeeId), SupervisorMembershipEntity.IndexByEmployee.GenerateRowKey()); if (index == null) { return(null); } var entity = await _tableStorage.GetDataAsync(index); return(Mapper.Map <Core.Domain.SupervisorMembership.SupervisorMembership>(entity)); }
public async Task <IVirtualWallet> FindAsync(string walletId) { AzureIndex index = await _walletIdIndexStorage.GetDataAsync( VirtualWalletEntity.IndexByWalletId.GeneratePartitionKey(walletId), VirtualWalletEntity.IndexByWalletId.GenerateRowKey()); if (index == null) { return(null); } VirtualWalletEntity entity = await _tableStorage.GetDataAsync(index); return(Mapper.Map <VirtualWallet>(entity)); }
public async Task <Core.Domain.ResetPasswordAccessToken> GetByPublicIdAsync(string publicId) { AzureIndex index = await _indexByPublicIdStorage.GetDataAsync( ResetPasswordAccessTokenEntity.IndexByPublicId.GeneratePartitionKey(publicId), ResetPasswordAccessTokenEntity.IndexByPublicId.GenerateRowKey()); if (index == null) { return(null); } ResetPasswordAccessTokenEntity entity = await _storage.GetDataAsync(index); return(Mapper.Map <Core.Domain.ResetPasswordAccessToken>(entity)); }
public async Task <IMerchantWallet> GetByAddressAsync(BlockchainType network, string walletAddress) { AzureIndex index = await _indexByAddressStorage.GetDataAsync( MerchantWalletEntity.IndexByAddress.GeneratePartitionKey(network, walletAddress), MerchantWalletEntity.IndexByAddress.GenerateRowKey()); if (index == null) { throw new KeyNotFoundException(); } MerchantWalletEntity entity = await _tableStorage.GetDataAsync(index); return(Mapper.Map <Core.Domain.MerchantWallet.MerchantWallet>(entity)); }
public async Task <IPaymentRequest> FindAsync(string walletAddress) { AzureIndex index = await _walletAddressIndexStorage.GetDataAsync( PaymentRequestEntity.IndexByWallet.GeneratePartitionKey(walletAddress), PaymentRequestEntity.IndexByWallet.GenerateRowKey()); if (index == null) { return(null); } PaymentRequestEntity entity = await _storage.GetDataAsync(index); return(Mapper.Map <Core.Domain.PaymentRequests.PaymentRequest>(entity)); }
public async Task ShouldSaveQuotes() { var quotes = new[] { _rur, _usd }; await _repository.SaveAsync(quotes); var stored = await _storage.GetDataAsync(); Assert.That(stored.Count, Is.EqualTo(2)); Assert.That(stored.Count(s => s.Id == _rur.AssetPair), Is.EqualTo(1)); Assert.That(stored.Count(s => s.Id == _usd.AssetPair), Is.EqualTo(1)); }
public async Task <IEnumerable <ILogItem> > GetRange(DateTime dateFrom, DateTime dateTo, string clientId) { DateTime startDate = dateFrom.Date; DateTime endDate = dateTo.Date.AddDays(1); DateTime currentDate = startDate; List <LogEntity> retval = new List <LogEntity>(); do { string partitionKey = LogEntity.GetPartitionKey(clientId, currentDate); var entities = (await _storage.GetDataAsync(new[] { partitionKey }, int.MaxValue)) .OrderByDescending(item => item.Timestamp); retval.AddRange(entities); currentDate = currentDate.AddDays(1); } while (currentDate < endDate); //var entities = (await _storage.GetDataAsync(new[] { clientId }, int.MaxValue, // entity => entity.Timestamp >= dateFrom && entity.Timestamp < dateTo)) // .OrderByDescending(item => item.Timestamp); return(retval.Select(LogEntity.CreateDto)); }
public async Task <Core.Domain.Transfer.Transfer> GetAsync(string id) { AzureIndex index = await _transferIdIndexStorage.GetDataAsync( TransferEntity.IndexById.GeneratePartitionKey(id), TransferEntity.IndexById.GenerateRowKey()); if (index == null) { return(null); } TransferEntity entity = await _storage.GetDataAsync(index); return(Mapper.Map <Core.Domain.Transfer.Transfer>(entity)); }
public async Task <IClientAccount> AuthenticateAsync(string email, string password) { if (email == null || password == null) { return(null); } var indexEntity = await _emailIndices.GetDataAsync(IndexEmail, email.ToLower()); if (indexEntity == null) { return(null); } var entity = await _clientsTablestorage.GetDataAsync(indexEntity); if (entity == null) { return(null); } return(entity.CheckPassword(password) ? entity : null); }
public async Task <DistributionPlanAggregate> TryGetAsync( Guid planId) { var indexEntity = await _distributionPlanIndexTable.GetDataAsync ( partition : GetIndexPartitionKey(planId), row : GetIndexRowKey() ); if (indexEntity == null) { return(null); } var planEntity = await _distributionPlanTable.GetDataAsync ( partition : indexEntity.PrimaryPartitionKey, row : indexEntity.PrimaryRowKey ); if (planEntity == null) { return(null); } var amountEntities = new List <DistributionAmountEntity>(); var amountPartitionKey = GetAmountPartitionKey(planEntity.PlanTimestamp); var continuationToken = (string)null; do { IEnumerable <DistributionAmountEntity> entities; (entities, continuationToken) = await _distributionAmountTable .GetDataWithContinuationTokenAsync(amountPartitionKey, 1000, continuationToken); amountEntities.AddRange(entities); } while (continuationToken != null); return(DistributionPlanAggregate.Restore ( planEntity.PlanId, planEntity.PlanTimestamp, amountEntities .Select(x => DistributionPlanAggregate.Amount.Restore(walletId: x.WalletId, amountId: x.AmountId, value: x.AmountValue)) .ToArray() )); }
public async Task <TxBuild> GetAsync(Guid operationId) { var entity = await _table.GetDataAsync(GetPartitionKey(), GetRowKey(operationId)); if (entity != null) { return(new TxBuild { OperationId = entity.OperationId, Timestamp = entity.Timestamp, XdrBase64 = entity.XdrBase64 }); } return(null); }
public async Task <Employee> FindAsync(string email) { AzureIndex index = await _indexStorage.GetDataAsync(GetEmailIndexPartitionKey(), GetEmailIndexRowKey(email)); if (index == null) { return(null); } EmployeeEntity entity = await _storage.GetDataAsync(index); var employee = Mapper.Map <Employee>(entity); return(employee); }
public async Task <Invoice> FindByPaymentRequestIdAsync(string paymentRequestId) { AzureIndex index = await _paymentRequestIdIndexStorage.GetDataAsync(GetPaymentRequestIndexPartitionKey(paymentRequestId), GetPaymentRequestIndexRowKey()); if (index == null) { return(null); } InvoiceEntity entity = await _storage.GetDataAsync(index); var invoice = Mapper.Map <Invoice>(entity); return(invoice); }
public async Task <IEnumerable <IClientAccount> > GetByEmailAsync(string email) { if (string.IsNullOrEmpty(email)) { return(null); } IEnumerable <ClientPartnerRelationEntity> relations = await _clientPartnerTablestorage.GetDataAsync(ClientPartnerRelationEntity.GeneratePartitionKey(email)); IEnumerable <string> rowKeys = relations.Select(x => x.ClientId); return((await _clientsTablestorage.GetDataAsync(ClientAccountEntity.GeneratePartitionKey(), rowKeys)) .Append(await _clientsTablestorage.GetDataAsync(_emailIndices, IndexEmail, GetEmailPartnerIndexRowKey(email, null))) .Except(new ClientAccountEntity[] { null }, ClientAccountEntity.ComparerById) .Distinct(ClientAccountEntity.ComparerById).ToArray()); }
private static async Task DeleteCodesInRepository <T>(string partnerId, string phoneNum, INoSQLTableStorage <T> storage) where T : ITableEntity, new() { var batchOperation = new TableBatchOperation(); var entitiesToDelete = (await storage.GetDataAsync(SmsVerificationCodeEntity.GeneratePartitionKey(partnerId, phoneNum))) .ToArray(); if (entitiesToDelete.Any()) { foreach (var e in entitiesToDelete) { batchOperation.Delete(e); } await storage.DoBatchAsync(batchOperation); } }
private async Task CheckIsEncrypted(TestEntity entity) { var plain = await Storage.GetDataAsync(entity.PartitionKey, entity.RowKey); var encrypted = await _innerStorage.GetDataAsync(entity.PartitionKey, entity.RowKey); Assert.IsTrue(_cryptoSerializer.IsEncrypted(encrypted.PropertyAsEncrypted)); Assert.AreEqual(plain.PropertyAsEncrypted, _cryptoSerializer.Deserialize(encrypted.PropertyAsEncrypted)); Assert.IsFalse(_cryptoSerializer.IsEncrypted(encrypted.PlainProperty)); Assert.AreEqual(plain.PlainProperty, encrypted.PlainProperty); if (plain.SecondPropertyAsEncrypted != null) { Assert.IsTrue(_cryptoSerializer.IsEncrypted(encrypted.SecondPropertyAsEncrypted)); Assert.AreEqual(plain.SecondPropertyAsEncrypted, _cryptoSerializer.Deserialize(encrypted.SecondPropertyAsEncrypted)); } }
public static async Task <T> GetFirstOrDefaultAsync <T>(this INoSQLTableStorage <AzureMultiIndex> indexTable, string partitionKey, string rowKey, INoSQLTableStorage <T> dataTable) where T : class, ITableEntity, new() { var indexEntity = await indexTable.GetDataAsync(partitionKey, rowKey); if (indexEntity == null) { return(null); } var indices = indexEntity.GetData(); if (indices.Length == 0) { return(null); } return(await dataTable.GetDataAsync(indices[0].Pk, indices[0].Rk)); }
public async Task <IEnumerable <IBestBidAsk> > GetRange(DateTime dateFrom, DateTime dateTo, string assetPair) { DateTime currentDate = dateFrom.Date; List <BestBidAskEntity> retval = new List <BestBidAskEntity>(); do { string PartitionKey = string.Format("{0}_{1}", assetPair, currentDate.ToString("yyyyMMdd_HH")); var entities = (await _storage.GetDataAsync(new[] { PartitionKey }, int.MaxValue)) .OrderByDescending(item => item.Timestamp); retval.AddRange(entities); // Next partition key (hours) currentDate = currentDate.AddHours(1); } while (currentDate < dateTo.Date.AddDays(1)); return(retval.Select(BestBidAskEntity.CreateDto)); }
public async Task <IEnumerable <IAuditLog> > GetLogsAsync(AuditLogsQuery query) { IEnumerable <IAuditLog> logs; if (!string.IsNullOrEmpty(query.Author)) { var authorIndexes = await _authorIndex.GetDataAsync(AuditLogEntity.GenerateAuthorIndexPk(query.Author)); logs = (await _tableStorage.GetDataAsync(authorIndexes)) .Where(entity => entity.PartitionKey == AuditLogEntity.GenerateTypePk(query.Type)); } else { logs = await _tableStorage.GetDataAsync(AuditLogEntity.GenerateTypePk(query.Type)); } return(logs.Where(item => (!query.StartDate.HasValue || item.CreateDate >= query.StartDate) && (!query.EndDate.HasValue || item.CreateDate <= query.EndDate))); }
public async Task <Transaction> TryGetAsync( Guid transactionId) { var(partitionKey, rowKey) = GetTransactionKeys(transactionId); var transactionEntity = await _transactions.GetDataAsync ( partition : partitionKey, row : rowKey ); if (transactionEntity != null) { return(new Transaction ( amount: transactionEntity.Amount, blockNumber: transactionEntity.BlockNumber, broadcastedOn: transactionEntity.BroadcastedOn, builtOn: transactionEntity.BuiltOn, completedOn: transactionEntity.CompletedOn, confirmationLevel: transactionEntity.ConfirmationLevel, confirmedOn: transactionEntity.ConfirmedOn, data: transactionEntity.Data, deletedOn: transactionEntity.DeletedOn, error: transactionEntity.Error, from: transactionEntity.From, gasAmount: transactionEntity.GasAmount, gasPrice: transactionEntity.GasPrice, hash: transactionEntity.Hash, includeFee: transactionEntity.IncludeFee, isConfirmed: transactionEntity.IsConfirmed, nonce: transactionEntity.Nonce, signedData: transactionEntity.SignedData, state: transactionEntity.State, to: transactionEntity.To, transactionId: transactionEntity.TransactionId )); } else { return(null); } }
public async Task Delete(string transactionHash) { AzureIndex index = await _index.GetDataAsync(_indexName, transactionHash); if (index == null) { return; } IPendingTransaction transaction = await _table.GetDataAsync(index); if (transaction == null) { return; } await _table.DeleteIfExistAsync(PendingTransactionEntity.GeneratePartitionKey(transaction.CoinAdapterAddress), transaction.UserAddress); await _table.DeleteIfExistAsync(_indexName, index.RowKey); }
public async Task <WalletDto> TryGetAsync(string blockchainType, string address) { var(indexPartitionKey, indexRowKey) = GetAddressIndexKeys(blockchainType, address); var index = await _addressIndexTable.GetDataAsync ( partition : indexPartitionKey, row : indexRowKey ); if (index != null) { var entity = await _walletsTable.GetDataAsync(index.PrimaryPartitionKey, index.PrimaryRowKey); return(entity != null ? ConvertEntityToDto(entity) : null); } return(null); }
public async Task <IEnumerable <IUserHistoryItem> > GetUserHistory(string userId, DateTime dateFrom, DateTime dateTo) { DateTime startDate = dateFrom.Date; DateTime endDate = dateTo.Date.AddDays(1); DateTime currentDate = startDate; List <UserHistoryEntity> retval = new List <UserHistoryEntity>(); do { string partitionKey = UserHistoryEntity.GetPartitionKey(userId, currentDate); var entities = (await _hstorage.GetDataAsync(new[] { partitionKey }, int.MaxValue)) .OrderByDescending(item => item.Timestamp); retval.AddRange(entities); currentDate = currentDate.AddDays(1); } while (currentDate < endDate); return(retval.Select(UserHistoryEntity.CreateDto)); }
public async Task RemoveOutputsAsync(IEnumerable <IOutput> outputs) { foreach (var output in outputs) { var index = await _indexByTransactionHash.GetDataAsync( IndexByTransactionHash.GeneratePartitionKey(output.TransactionHash), IndexByTransactionHash.GenerateRowKey(output.N)); if (index != null) { var entity = await _storage.DeleteAsync(index); if (entity != null) { await _indexByAddress.DeleteAsync(IndexByAddress.GeneratePartitionKey(entity.Address), IndexByAddress.GenerateRowKey(entity.TransactionHash, entity.N)); } await _indexByTransactionHash.DeleteAsync(index); } } }
public async Task <string> GetUser(string lykkeUserId, bool createIfNotExists = true) { if (string.IsNullOrEmpty(lykkeUserId)) { throw new ArgumentNullException(nameof(lykkeUserId)); } var result = await _repository.GetDataAsync(ProxyUser.GetPartitionKey(), lykkeUserId); if (result == null && createIfNotExists) { result = new ProxyUser { PartitionKey = ProxyUser.GetPartitionKey(), LykkeUserId = lykkeUserId, UserId = Guid.NewGuid().ToString() }; await _repository.InsertOrMergeAsync(result); } return(result?.UserId); }
public async Task <IGasPrice> GetAsync() { var entity = await _table.GetDataAsync(PartitionKey, RowKey); if (entity != null) { return(new GasPrice { Max = BigInteger.Parse(entity.Max), Min = BigInteger.Parse(entity.Min) }); } else { return(new GasPrice { Max = 120000000000, Min = 100000000000 }); } }
public async Task <bool> IsEmailRegistered(string email) { if (IsEmailRegisteredFromCache(email)) { return(true); } var patitionKey = Lkk2YOrderMadeIndexEntity.GeneratePartitionKey(); var rowKey = Lkk2YOrderMadeIndexEntity.GenerateRowKey(email); var entity = await _tableStorageOrderIndex.GetDataAsync(patitionKey, rowKey); var result = entity != null; if (result) { AddToCache(email); } return(result); }
public async Task ClearBlockAsync( BigInteger blockNumber) { var byBlockIndexPartitionKey = GetByBlockIndexPartitionKey(blockNumber); var receiptsInBlock = await _byBlockIndices.GetDataAsync(byBlockIndexPartitionKey); foreach (var receiptInBlock in receiptsInBlock) { var receiptEntity = await _transactionReceipts.GetDataAsync ( partition : receiptInBlock.PrimaryPartitionKey, row : receiptInBlock.PrimaryRowKey ); if (receiptEntity != null) { var byFromIndexKeys = GetByFromIndexKeys(receiptEntity); var byToIndexKeys = GetByToIndexKeys(receiptEntity); await Task.WhenAll ( _byFromIndices.DeleteIfExistAsync ( byFromIndexKeys.PartitionKey, byFromIndexKeys.RowKey ), _byToIndices.DeleteIfExistAsync ( byToIndexKeys.PartitionKey, byToIndexKeys.RowKey ) ); await _transactionReceipts.DeleteIfExistAsync(receiptEntity.PartitionKey, receiptEntity.RowKey); } await _byBlockIndices.DeleteIfExistAsync(receiptInBlock.PartitionKey, receiptInBlock.RowKey); } }