public Task UpdateAsync(Settlement settlement) { return(_storage.MergeAsync(GetPartitionKey(settlement.Id), GetRowKey(settlement.Id), entity => { Mapper.Map(settlement, entity); return entity; })); }
public async Task SetStatusAsync(string merchantId, string invoiceId, InvoiceStatus status) { await _storage.MergeAsync(GetPartitionKey(merchantId), GetRowKey(invoiceId), entity => { entity.Status = status.ToString(); return(entity); }); }
public async Task <Employee> MarkDeletedAsync(string merchantId, string employeeId) { var entity = await _storage.MergeAsync(GetPartitionKey(merchantId), GetRowKey(employeeId), mergingEntity => { mergingEntity.IsDeleted = true; return(mergingEntity); }); return(Mapper.Map <Employee>(entity)); }
public async Task <IBitcoinTransaction> SaveResponseAndHashAsync(string transactionId, string resp, string hash, DateTime?dateTime = null) { var partitionKey = BitCoinTransactionEntity.ByTransactionId.GeneratePartitionKey(); var rowKey = BitCoinTransactionEntity.ByTransactionId.GenerateRowKey(transactionId); return(await _tableStorage.MergeAsync(partitionKey, rowKey, entity => { entity.UpdateResponse(resp, dateTime); entity.BlockchainHash = hash; return entity; })); }
public async Task AddChildTransfer(string transferId, IOffchainTransfer child) { await _storage.MergeAsync(OffchainTransferEntity.ByCommon.GeneratePartitionKey(), transferId, entity => { var data = entity.GetAdditionalData(); data.ChildTransfers.Add(child.Id); entity.SetAdditionalData(data); entity.Amount += child.Amount; return(entity); }); }
public static async Task <T> MergeAsync <T>(this INoSQLTableStorage <AzureMultiIndex> indexTable, string partitionKey, string rowKey, INoSQLTableStorage <T> dataTable, Func <T, T> replaceCallback) 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); } var tasks = new List <Task <T> >(); foreach (var index in indices) { var task = dataTable.MergeAsync(index.Pk, index.Rk, replaceCallback); tasks.Add(task); } await Task.WhenAll(tasks); return(tasks[0].Result); }
public async Task <Core.Domain.ResetPasswordAccessToken> UpdateAsync(Core.Domain.ResetPasswordAccessToken src) { AzureIndex index = await _indexByPublicIdStorage.GetDataAsync( ResetPasswordAccessTokenEntity.IndexByPublicId.GeneratePartitionKey(src.PublicId), ResetPasswordAccessTokenEntity.IndexByPublicId.GenerateRowKey()); if (index == null) { throw new KeyNotFoundException(); } ResetPasswordAccessTokenEntity updatedEntity = await _storage.MergeAsync( ResetPasswordAccessTokenEntity.ByEmployeeId.GeneratePartitionKey(index.PrimaryPartitionKey), ResetPasswordAccessTokenEntity.ByEmployeeId.GenerateRowKey(index.PrimaryRowKey), entity => { entity.Redeemed = src.Redeemed; return(entity); }); if (updatedEntity == null) { throw new KeyNotFoundException(); } return(Mapper.Map <Core.Domain.ResetPasswordAccessToken>(updatedEntity)); }
public async Task <IAssetGeneralSettings> SetAsync(IAssetGeneralSettings availability) { string partitionKey = AssetGeneralSettingsEntity.ByAsset.GeneratePartitionKey(availability.AssetId); string rowKey = AssetGeneralSettingsEntity.ByAsset.GenerateRowKey(availability.AssetId); AssetGeneralSettingsEntity exItem = await _tableStorage.GetDataAsync(partitionKey, rowKey); if (exItem != null) { AssetGeneralSettingsEntity merged = await _tableStorage.MergeAsync(partitionKey, rowKey, item => { item.PaymentAvailable = availability.PaymentAvailable; item.SettlementAvailable = availability.SettlementAvailable; item.AutoSettle = availability.AutoSettle; item.Network = availability.Network; return(item); }); return(Mapper.Map <AssetGeneralSettings>(merged)); } var newItem = AssetGeneralSettingsEntity.ByAsset.Create(availability); await _tableStorage.InsertAsync(newItem); return(Mapper.Map <AssetGeneralSettings>(newItem)); }
public async Task UpdateAsync(IMerchantConfigurationLine src) { string pKey = MerchantConfigurationLineEntity.ByMerchant.GeneratePartitionKey(src.MerchantId); string rKey = MerchantConfigurationLineEntity.ByMerchant.GenerateRowKey(src.RuleId); MerchantConfigurationLineEntity updatedEntity = await _storage.MergeAsync(pKey, rKey, entity => { if (src.RuleInput != null) { entity.RuleInput = src.RuleInput; } if (src.Enabled.HasValue) { entity.Enabled = src.Enabled.Value; } return(entity); }); if (updatedEntity == null) { throw new EntityNotFoundException(pKey, rKey); } }
public async Task <OperationEntity> UpdateAsync(Guid operationId, DateTime?sendTime = null, DateTime?completionTime = null, DateTime?blockTime = null, DateTime?failTime = null, DateTime?deleteTime = null, string transactionHash = null, long?blockNumber = null, string error = null, BlockchainErrorCode?errorCode = null, string broadcastResult = null) { if (!string.IsNullOrEmpty(transactionHash)) { await _operationIndexStorage.InsertOrReplaceAsync(new OperationIndexEntity(transactionHash, operationId)); } return(await _operationStorage.MergeAsync( OperationEntity.Partition(operationId), OperationEntity.Row(), op => { op.SendTime = sendTime ?? op.SendTime; op.CompletionTime = completionTime ?? op.CompletionTime; op.BlockTime = blockTime ?? op.BlockTime; op.FailTime = failTime ?? op.FailTime; op.DeleteTime = deleteTime ?? op.DeleteTime; op.TransactionHash = transactionHash ?? op.TransactionHash; op.BlockNumber = blockNumber ?? op.BlockNumber; op.Error = error ?? op.Error; op.ErrorCode = errorCode ?? op.ErrorCode; op.BroadcastResult = broadcastResult ?? op.BroadcastResult; return op; } )); }
public async Task <IOffchainRequest> CreateRequestAndLock(string transferId, string clientId, string assetId, RequestType type, OffchainTransferType transferType, DateTime?lockDate) { var existingRequest = (await GetRequestsForClient(clientId)).FirstOrDefault(x => x.AssetId == assetId && x.TransferType == transferType && x.StartProcessing == null); if (existingRequest == null) { return(await CreateRequest(transferId, clientId, assetId, type, transferType, lockDate)); } var replaced = await _table.MergeAsync(OffchainRequestEntity.ByRecord.Partition, existingRequest.RequestId, entity => { if (entity.StartProcessing != null) { return(null); } entity.ServerLock = lockDate; return(entity); }); if (replaced == null) { return(await CreateRequest(transferId, clientId, assetId, type, transferType, lockDate)); } return(replaced); }
public async Task UpdateAsync( Transaction transaction) { TransactionEntity MergeAction(TransactionEntity entity) { entity.Amount = transaction.Amount; entity.BlockNumber = transaction.BlockNumber; entity.BroadcastedOn = transaction.BroadcastedOn; entity.BuiltOn = transaction.BuiltOn; entity.CompletedOn = transaction.CompletedOn; entity.Data = transaction.Data; entity.DeletedOn = transaction.DeletedOn; entity.Error = transaction.Error; entity.From = transaction.From; entity.GasAmount = transaction.GasAmount; entity.GasPrice = transaction.GasPrice; entity.Hash = transaction.Hash; entity.IncludeFee = transaction.IncludeFee; entity.SignedData = transaction.SignedData; entity.State = transaction.State; entity.To = transaction.To; entity.TransactionId = transaction.TransactionId; return(entity); } var(partitionKey, rowKey) = GetTransactionKeys(transaction.TransactionId); await _transactions.MergeAsync ( partitionKey : partitionKey, rowKey : rowKey, mergeAction : MergeAction ); }
public async Task UpdateAsync(IMerchantWallet src) { MerchantWalletEntity updatedEntity = await _tableStorage.MergeAsync( MerchantWalletEntity.ByMerchant.GeneratePartitionKey(src.MerchantId), MerchantWalletEntity.ByMerchant.GenerateRowKey(src.Network, src.WalletAddress), entity => { if (!string.IsNullOrEmpty(src.DisplayName)) { entity.DisplayName = src.DisplayName; } if (src.IncomingPaymentDefaults != null) { entity.IncomingPaymentDefaults = src.IncomingPaymentDefaults; } if (src.OutgoingPaymentDefaults != null) { entity.OutgoingPaymentDefaults = src.OutgoingPaymentDefaults; } return(entity); }); if (updatedEntity == null) { throw new KeyNotFoundException(); } }
public async Task SaveAsync(IVirtualWallet wallet) { string partitionKey = VirtualWalletEntity.ByMerchantId.GeneratePartitionKey(wallet.MerchantId); string rowKey = VirtualWalletEntity.ByMerchantId.GenerateRowKey(wallet.Id); VirtualWalletEntity exItem = wallet.Id != null ? await _tableStorage.GetDataAsync(partitionKey, rowKey) : null; if (exItem != null) { await _tableStorage.MergeAsync(partitionKey, rowKey, entity => { entity.BlockchainWallets = wallet.BlockchainWallets; return(entity); }); return; } VirtualWalletEntity newEntity = VirtualWalletEntity.ByMerchantId.Create(wallet); await _tableStorage.InsertAsync(newEntity); }
public async Task UpdateAsync(LegalEntity legalEntity) { await _storage.MergeAsync(GetPartitionKey(), GetRowKey(legalEntity.Id), entity => { Mapper.Map(legalEntity, entity); return(entity); }); }
public Task UpdateAsync(AssetPair assetPair) { return(_storage.MergeAsync(GetPartitionKey(assetPair.Exchange), GetRowKey(assetPair.Name), entity => { Mapper.Map(assetPair, entity); return entity; })); }
public Task UpdateAsync(MarketOrder marketOrder) { return(_storage.MergeAsync(GetPartitionKey(marketOrder.CreatedDate), GetRowKey(marketOrder.Id), entity => { Mapper.Map(marketOrder, entity); return entity; })); }
public async Task <T> MergeAsync(string partitionKey, string rowKey, Func <T, T> item) { var result = await _table.MergeAsync(partitionKey, rowKey, item); await _cache.MergeAsync(partitionKey, rowKey, item); return(result); }
public async Task UpdateAsync(IDisclaimer disclaimer) { await _storage.MergeAsync(GetPartitionKey(disclaimer.LykkeEntityId), GetRowKey(disclaimer.Id), entity => { Mapper.Map(disclaimer, entity); return(entity); }); }
public async Task UpdateAsync(RemainingVolume remainingVolume) { await _storage.MergeAsync(GetPartitionKey(), GetRowKey(remainingVolume.AssetPairId), entity => { Mapper.Map(remainingVolume, entity); return(entity); }); }
public async Task UpdateAsync(Instrument instrument) { await _storage.MergeAsync(GetPartitionKey(), GetRowKey(instrument.AssetPair), entity => { Mapper.Map(instrument, entity); return(entity); }); }
public async Task UpdateAsync(IndexPrice indexPrice) { await _storage.MergeAsync(GetPartitionKey(), GetRowKey(indexPrice.Name), entity => { Mapper.Map(indexPrice, entity); return(entity); }); }
public async Task UpdateAsync(IFileInfo fileInfo) { await _storage.MergeAsync(GetPartitionKey(fileInfo.InvoiceId), fileInfo.FileId, entity => { Mapper.Map(fileInfo, entity); return(entity); }); }
public async Task UpdateAsync(SummaryReport summaryReport) { await _storage.MergeAsync(GetPartitionKey(summaryReport.AssetPairId), GetRowKey(summaryReport.TradeAssetPairId), entity => { Mapper.Map(summaryReport, entity); return(entity); }); }
public async Task UpdateAsync(Domain.AssetSettings assetSettings) { await _storage.MergeAsync(GetPartitionKey(), GetRowKey(assetSettings.AssetId), entity => { Mapper.Map(assetSettings, entity); return(entity); }); }
public async Task UpdateAsync(Position position) { await _storage.MergeAsync(GetPartitionKey(position.Exchange), GetRowKey(position.AssetId), entity => { Mapper.Map(position, entity); return(entity); }); }
public async Task UpdateAsync(AssetPairLink assetPairLink) { await _storage.MergeAsync(GetPartitionKey(), GetRowKey(assetPairLink.AssetPairId), entity => { Mapper.Map(assetPairLink, entity); return(entity); }); }
public async Task <IPaymentTransaction> SetStatus(string id, PaymentStatus status) { return(await _tableStorageIndices.MergeAsync(IndexPartitinKey, id, _tableStorage, entity => { entity.SetPaymentStatus(status); return entity; })); }
public async Task UpdateAsync(PnLStopLossEngine pnLStopLossEngine) { await _storage.MergeAsync(GetPartitionKey(), GetRowKey(pnLStopLossEngine.Id), entity => { Mapper.Map(pnLStopLossEngine, entity); return(entity); }); }
public async Task UpdateAsync(IndexSettings indexSettings) { await _storage.MergeAsync(GetPartitionKey(), GetRowKey(indexSettings.Name), entity => { Mapper.Map(indexSettings, entity); return(entity); }); }