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 InsertOrReplaceAsync(IBcnCredentialsRecord credsRecord) { var byClientEntity = FirstGenerationBlockchainWalletEntity.FromBcnClientCredentials.ByClientId.Create(credsRecord); var byAssetAddressEntity = FirstGenerationBlockchainWalletEntity.FromBcnClientCredentials.ByAssetAddress.Create(credsRecord); await _bcnClientCredentialsWalletTable.InsertOrReplaceAsync(byClientEntity); await _bcnClientCredentialsWalletTable.InsertOrReplaceAsync(byAssetAddressEntity); }
public async Task <IMarginTradingWatchList> AddAsync(IMarginTradingWatchList watchList) { await _tableStorage.InsertOrReplaceAsync(MarginTradingWatchListEntity.Create(watchList)); var entity = await _tableStorage.GetDataAsync(MarginTradingWatchListEntity.GeneratePartitionKey(watchList.ClientId), MarginTradingWatchListEntity.GenerateRowKey(watchList.Id)); return(MarginTradingWatchList.Create(entity)); }
public async Task UpdateAsync(IEthereumTransactionRequest request) { var byId = EthereumTransactionReqEntity.ById.Create(request); await _tableStorage.InsertOrReplaceAsync(byId); if (!string.IsNullOrEmpty(request.OrderId)) { var byOrder = EthereumTransactionReqEntity.ByOrderId.Create(request); await _tableStorage.InsertOrReplaceAsync(byOrder); } }
public async Task AddAsync(string clientId, AccountTier tier, KycStatus status, string comment = null, DateTime?date = null) { var item = TierUpgradeRequestEntity.Create(clientId, tier, status, comment, date); await _tableStorage.InsertOrReplaceAsync(item); if (status == KycStatus.Pending) { var indexEntity = AzureIndex.Create(PendingRequestsIndex, GetPendingRequestIndexRk(clientId, tier), item); await _index.InsertOrMergeAsync(indexEntity); } }
public async Task <IOffchainRequest> CreateRequest(string transferId, string clientId, string assetId, RequestType type, OffchainTransferType transferType, DateTime?serverLock = null) { var id = Guid.NewGuid().ToString(); var byClient = OffchainRequestEntity.ByClient.Create(id, transferId, clientId, assetId, type, transferType, serverLock); await _table.InsertOrReplaceAsync(byClient); var byRecord = OffchainRequestEntity.ByRecord.Create(id, transferId, clientId, assetId, type, transferType, serverLock); await _table.InsertOrReplaceAsync(byRecord); return(byRecord); }
//clientLatestDepositIndexManualPartitionKey let it be null for common operations public async Task AddAsync(string blockchainType, Guid clientId, string address, CreatorType createdBy, string clientLatestDepositIndexManualPartitionKey = null, bool addAsLatest = true) { var partitionKey = BlockchainWalletEntity.GetPartitionKey(blockchainType, clientId); var rowKey = BlockchainWalletEntity.GetRowKey(address); var clientLatestDepositIndexPartitionKey = GetClientLatestIndexPartitionKey(clientId); var clientLatestDepositIndexRowKey = GetClientLatestIndexRowKey(blockchainType); var(indexPartitionKey, indexRowKey) = GetAddressIndexKeys(blockchainType, address); var(clientBtIndexPartitionKey, clientBtIndexRowKey) = GetClientBlockchainTypeIndexKeys(blockchainType, clientId); clientBtIndexRowKey = clientLatestDepositIndexManualPartitionKey ?? clientBtIndexRowKey; await _addressIndexTable.InsertOrReplaceAsync(new AzureIndex( indexPartitionKey, indexRowKey, partitionKey, rowKey )); await _clientBlockchainTypeIndexTable.InsertOrReplaceAsync(new AzureIndex( clientBtIndexPartitionKey, clientBtIndexRowKey, partitionKey, rowKey )); if (addAsLatest) { await _clientLatestDepositsIndexTable.InsertOrReplaceAsync(new AzureIndex( clientLatestDepositIndexPartitionKey, clientLatestDepositIndexRowKey, partitionKey, rowKey )); } // Wallet entity await _walletsTable.InsertOrReplaceAsync(new BlockchainWalletEntity { PartitionKey = partitionKey, RowKey = rowKey, Address = address, ClientId = clientId, IntegrationLayerId = blockchainType, CreatedBy = createdBy }); }
public async Task <ISpiderDocumentInfo> AddOrUpdateAsync(ISpiderDocumentInfo entity) { var newEntity = SpiderDocumentInfoEntity.Create(entity); await _tableStorage.InsertOrReplaceAsync(newEntity); return(newEntity); }
public async Task <ICustomerChecksInfo> AddAsync(ICustomerChecksInfo entity) { var newEntity = CustomerChecksInfoEntity.Create(entity); await _tableStorage.InsertOrReplaceAsync(newEntity); return(newEntity); }
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 UpdateOrderAsync(OrderBase updatedOrder) { var partitionKey = OrderEntity.GeneratePartitionKey(updatedOrder.TraderId); var rowKey = OrderEntity.GenerateRowKey(updatedOrder.Id); var oldStatus = OrderStatus.Registered; await _tableStorage.ReplaceAsync(partitionKey, rowKey, itm => { oldStatus = itm.GetOrder().Status; itm.SetOrder(updatedOrder); return(itm); }); if (oldStatus == updatedOrder.Status) { await _tableStorage.ReplaceAsync(OrderEntity.GeneratePartitionAsAllOrders(oldStatus), rowKey, itm => { itm.SetOrder(updatedOrder); return(itm); }); return; } partitionKey = OrderEntity.GeneratePartitionAsAllOrders(oldStatus); await _tableStorage.DeleteAsync(partitionKey, rowKey); var newEntity = OrderEntity.Create(updatedOrder); await _tableStorage.InsertOrReplaceAsync(newEntity); }
public Task InsertSpentOutputsAsync(Guid operationId, IEnumerable <IOutput> outputs) { var entities = outputs.Select(o => SpentOutputEntity.Create(o.TransactionHash, o.N, operationId)); return(Task.WhenAll(entities.GroupBy(o => o.PartitionKey) .Select(group => _table.InsertOrReplaceAsync(group)))); }
public async Task AddOrReplaceAsync(GasPriceEntity entity) { entity.PartitionKey = GetPartitionKey(); entity.RowKey = GetRowKey(); await _table.InsertOrReplaceAsync(entity); }
public async Task <ISpiderCheckResult> AddAsync(ISpiderCheckResult entity) { var newEntity = SpiderCheckResultEntity.Create(entity); await _tableStorage.InsertOrReplaceAsync(newEntity); return(newEntity); }
public async Task UpdateBlockchainHashAsync(string clientId, string id, string hash) { var partitionkey = CashInOutOperationEntity.ByClientId.GeneratePartitionKey(clientId); var rowKey = CashInOutOperationEntity.ByClientId.GenerateRowKey(id); var record = await _tableStorage.GetDataAsync(partitionkey, rowKey); var multisigPartitionkey = CashInOutOperationEntity.ByMultisig.GeneratePartitionKey(record.Multisig); var multisigRowKey = CashInOutOperationEntity.ByMultisig.GenerateRowKey(id); var indexEntity = AzureIndex.Create(hash, rowKey, partitionkey, rowKey); await _blockChainHashIndices.InsertOrReplaceAsync(indexEntity); await _tableStorage.MergeAsync(partitionkey, rowKey, entity => { entity.BlockChainHash = hash; entity.State = TransactionStates.SettledOnchain; return(entity); }); await _tableStorage.MergeAsync(multisigPartitionkey, multisigRowKey, entity => { entity.BlockChainHash = hash; entity.State = TransactionStates.SettledOnchain; return(entity); }); }
public Task AddAsync(long brokerAccountId, long cursor) { return(_tableStorage.InsertOrReplaceAsync(new CursorEntity { PartitionKey = brokerAccountId.ToString(), RowKey = CursorEntity.GetRk(), Cursor = cursor })); }
public async Task UpdateBlockChainHashAsync(string clientId, string id, string blockChainHash) { var partitionKey = TransferEventEntity.ByClientId.GeneratePartitionKey(clientId); var rowKey = TransferEventEntity.ByClientId.GenerateRowKey(id); var item = await _tableStorage.GetDataAsync(partitionKey, rowKey); if (item.State == TransactionStates.SettledOffchain || item.State == TransactionStates.InProcessOffchain) { return; } item.BlockChainHash = blockChainHash; var multisigPartitionKey = TransferEventEntity.ByMultisig.GeneratePartitionKey(item.Multisig); var multisigRowKey = TransferEventEntity.ByMultisig.GenerateRowKey(id); var multisigItem = await _tableStorage.GetDataAsync(multisigPartitionKey, multisigRowKey); multisigItem.BlockChainHash = blockChainHash; multisigItem.State = TransactionStates.SettledOnchain; var indexEntity = AzureIndex.Create(blockChainHash, rowKey, partitionKey, rowKey); await _blockChainHashIndices.InsertOrReplaceAsync(indexEntity); await _tableStorage.InsertOrReplaceAsync(item); await _tableStorage.InsertOrReplaceAsync(multisigItem); }
public Task <bool> UpdateBalanceAsync(string walletId, IWallet wallet, long updateSequenceNumber) { var entity = WalletEntity.Create(walletId, wallet, updateSequenceNumber); return(_tableStorage.InsertOrReplaceAsync(entity, x => x.UpdateSequenceNumber == null || x.UpdateSequenceNumber.Value < updateSequenceNumber)); }
public async Task UpsertAsync(string assetId, string address, string name, int accuracy) { var asset = new AssetEntity(assetId, address, name, accuracy); await _tableStorage.InsertOrReplaceAsync(asset); _cache.AddOrUpdate(assetId, asset, (id, _) => asset); }
public async Task SaveAsync( SnapshotAggregate snapshot) { await _balanceTable.InsertOrReplaceBatchAsync ( snapshot.Balances.Select(x => new SnapshotBalanceEntity { BalanceValue = x.Value, SnapshotTimestamp = snapshot.Timestamp, WalletId = x.WalletId, PartitionKey = $"{GetSnapshotPartitionKey(snapshot.Timestamp)}-{GetSnapshotRowKey(snapshot.Timestamp)}", RowKey = $"{x.WalletId}" }) ); _chaosKitty.Meow(snapshot.Timestamp); await _snapshotTable.InsertOrReplaceAsync(new SnapshotEntity { SnapshotTimestamp = snapshot.Timestamp, PartitionKey = GetSnapshotPartitionKey(snapshot.Timestamp), RowKey = GetSnapshotRowKey(snapshot.Timestamp) }); }
public async Task InsertSpentOutputsAsync(Guid transactionId, IEnumerable <Output> outputs) { var entities = outputs.Select(o => SpentOutputEntity.Create(o.Hash, o.OutputIndex, transactionId)); await entities.GroupBy(o => o.PartitionKey) .ForEachAsyncSemaphore(8, group => _table.InsertOrReplaceAsync(group)); }
public async Task Save(IEventHistory eventHistory) { var now = DateTime.UtcNow; var entity = new EventHistoryEntity { PartitionKey = GeneratePartitionKey(eventHistory.TickPriceTimestamp ?? now), RowKey = GenerateRowKey(eventHistory.TickPriceTimestamp ?? now), Event = eventHistory.Event, Extreme = eventHistory.Extreme, ExpectedDcLevel = eventHistory.ExpectedDcLevel, ExpectedOsLevel = eventHistory.ExpectedOsLevel, Reference = eventHistory.Reference, ExpectedDirectionalChange = eventHistory.ExpectedDirectionalChange, DirectionalChangePrice = eventHistory.DirectionalChangePrice, AssetPair = eventHistory.AssetPair.ToUpperInvariant(), Delta = eventHistory.Delta, Exchange = eventHistory.Exchange.ToUpperInvariant(), Ask = eventHistory.Ask, Bid = eventHistory.Bid, TickPriceTimestamp = eventHistory.TickPriceTimestamp, DcTimestamp = eventHistory.DcTimestamp, IntrinsicEventIndicator = eventHistory.IntrinsicEventIndicator }; await _storage.InsertOrReplaceAsync(entity); }
public async Task <IRefund> AddAsync(string id, string clientId, string walletId, string feeClientId, string assetId, long siriusAssetId, decimal amount, decimal feeAmount) { var entity = RefundEntity.Create(id, clientId, walletId, feeClientId, assetId, siriusAssetId, amount, feeAmount); await _tableStorage.InsertOrReplaceAsync(entity); return(entity); }
public async Task Complete(string requestId) { var record = await _table.DeleteAsync(OffchainRequestEntity.ByRecord.Partition, requestId); await _table.DeleteAsync(OffchainRequestEntity.ByClient.GeneratePartition(record.ClientId), requestId); await _table.InsertOrReplaceAsync(OffchainRequestEntity.Archieved.Create(record)); }
/// <summary> /// Adds or entirely replaces a default asset conditions. /// </summary> /// <param name="layerId">The layer id.</param> /// <param name="assetDefaultCondition">The default asset conditons.</param> public async Task InsertOrReplaceAsync(string layerId, IAssetDefaultCondition assetDefaultCondition) { var entity = new AssetDefaultConditionEntity(GetPartitionKey(), GetRowKey(layerId), layerId); Mapper.Map(assetDefaultCondition, entity); await _storage.InsertOrReplaceAsync(entity); }
/// <summary> /// Adds or entirely replaces a default asset conditions layer. /// </summary> /// <param name="settings">The asset conditions layer settings.</param> public async Task InsertOrReplaceAsync(IAssetConditionLayerSettings settings) { var entity = new AssetDefaultConditionLayerEntity(GetPartitionKey(), GetRowKey()); Mapper.Map(settings, entity); await _storage.InsertOrReplaceAsync(entity); }
public async Task AddAsync(string address) { await _table.InsertOrReplaceAsync(new BalanceEntity { PartitionKey = GetPartitionKey(address), RowKey = GetRowKey(address) }); }
public async Task InsertOrReplaceAsync(Credit credit) { var entity = new CreditEntity(GetPartitionKey(), GetRowKey(credit.AssetId)); Mapper.Map(credit, entity); await _storage.InsertOrReplaceAsync(entity); }
public Task SetValueAsync(string partition, string field, string value) { var entity = new SetupByPartitionEntity { PartitionKey = partition, RowKey = field, Value = value }; return(_tableStorage.InsertOrReplaceAsync(entity)); }
public async Task UpdateAsync(TimerSettings timerSettings) { var entity = new TimerSettingsEntity(GetPartitionKey(), GetRowKey()); Mapper.Map(timerSettings, entity); await _storage.InsertOrReplaceAsync(entity); }