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 async Task <T> ReplaceAsync(string partitionKey, string rowKey, Func <T, T> replaceAction) { var result = await _table.ReplaceAsync(partitionKey, rowKey, replaceAction); await _cache.ReplaceAsync(partitionKey, rowKey, replaceAction); return(result); }
public Task SetBalance(string address, BigInteger balance) { return(_storage.ReplaceAsync(UserContractEntity.GeneratePartitionKey(), address, entity => { entity.BalanceStr = balance.ToString(); entity.LastCheck = DateTime.UtcNow; return entity; })); }
public Task ChangePhoneAsync(string clientId, string phoneNumber) { var partitionKey = ClientAccountEntity.GeneratePartitionKey(); var rowKey = ClientAccountEntity.GenerateRowKey(clientId); return(_clientsTablestorage.ReplaceAsync(partitionKey, rowKey, itm => { itm.Phone = phoneNumber; return itm; })); }
public Task ChangeFullNameAsync(string id, string fullName) { var partitionKey = PersonalDataEntity.GeneratePartitionKey(); var rowKey = PersonalDataEntity.GenerateRowKey(id); return(_tableStorage.ReplaceAsync(partitionKey, rowKey, itm => { itm.FullName = fullName; return itm; })); }
public Task SetStatus(string address, ReportStatus status) { return(_storage.ReplaceAsync(BaseReportMetadataEntity.GeneratePartitionKey(), BaseReportMetadataEntity.GenerateRowKey(address), p => { p.Status = status.ToString(); return p; })); }
public async Task CompleteTransfer(string transferId, bool?onchain = null) { await _storage.ReplaceAsync(OffchainTransferEntity.ByCommon.GeneratePartitionKey(), transferId, entity => { entity.Completed = true; if (onchain != null) { entity.Onchain = onchain.Value; } return(entity); }); }
public Task <TEntity> ReplaceAsync(string partitionKey, string rowKey, Func <TEntity, TEntity> replaceAction) { object result = "Not read"; return(WrapAsync(() => _impl.ReplaceAsync(partitionKey, rowKey, entity => { var replacedItem = replaceAction(entity); result = replacedItem; return replacedItem; }), nameof(ReplaceAsync), result)); }
public async Task SetChildFlags(IEnumerable <ICoinTransaction> transactions, List <string> clients) { foreach (var coinTransaction in transactions) { coinTransaction.HasChildClientA = clients.Contains(coinTransaction.ClientA); coinTransaction.HasChildClientB = clients.Contains(coinTransaction.ClientB); await _table.ReplaceAsync(CoinTransationEntity.Key, coinTransaction.RequestId.ToString(), entity => { entity.HasChildClientA = coinTransaction.HasChildClientA; entity.HasChildClientB = coinTransaction.HasChildClientB; return(entity); }); } }
public virtual async Task ReplaceAsync(TD obj) { var entity = ConvertService.Convert <TD, TE>(obj, DefaultAzureMappingOpts); entity.SetKeys(); await TableStorage.ReplaceAsync(entity); }
public async Task Save <TData>(IOperationExecutionInfo <TData> executionInfo) where TData : class { var entity = Convert(executionInfo); entity.LastModified = _dateService.Now(); await _tableStorage.ReplaceAsync(entity); }
public async Task ReplaceAsync(IMerchant merchant) { var entity = new MerchantEntity( MerchantEntity.ById.GeneratePartitionKey(merchant.Name), MerchantEntity.ById.GenerateRowKey(merchant.Name)); Mapper.Map(merchant, entity); entity.ETag = "*"; await _storage.ReplaceAsync(entity); if (!string.IsNullOrEmpty(merchant.Email)) { var existingEmailIndex = await _emailIndexStorage.GetDataAsync( MerchantEntity.IndexByEmail.GeneratePartitionKey(merchant.Email), MerchantEntity.IndexByEmail.GenerateRowKey()); if (existingEmailIndex == null) { var newEmailIndex = MerchantEntity.IndexByEmail.Create(entity); await _emailIndexStorage.InsertThrowConflict(newEmailIndex); } } }
public static async Task <T> InsertOrModifyAsync <T>(this INoSQLTableStorage <T> tableStorage, string partitionKey, string rowKey, Func <T> createNew, Func <T, T> modify) where T : class, ITableEntity, new() { for (var i = 0; i < 100; i++) { try { var result = await tableStorage.ReplaceAsync(partitionKey, rowKey, modify); if (result != null) { return(result); } result = createNew(); await tableStorage.InsertAsync(result); return(result); } catch { } } throw new Exception("Can not insert or modify entity"); }
public static async Task <T> ModifyOrCreateAsync <T>(this INoSQLTableStorage <T> tableStorage, string partitionKey, string rowKey, Func <T> create, Action <T> update) where T : ITableEntity, new() { for (var i = 0; i < 15; i++) { try { var entity = await tableStorage.ReplaceAsync(partitionKey, rowKey, itm => { update(itm); return(itm); }); if (entity != null) { return(entity); } entity = create(); await tableStorage.InsertAsync(entity); return(entity); } catch (Exception) { } } throw new Exception("Can not modify or update entity: " + PrintItem(create())); }
public async Task Save <TData>(IOperationExecutionInfo <TData> executionInfo) where TData : class { var entity = Convert(executionInfo); entity.LastModified = _systemClock.UtcNow.UtcDateTime; await _tableStorage.ReplaceAsync(entity); }
public async static Task<T> ReplaceAsync<T>(this INoSQLTableStorage<T> tableStorage, IAzureIndex index, Func<T, T> action) where T : class, ITableEntity, new() { if (index == null) return null; return await tableStorage.ReplaceAsync(index.PrimaryPartitionKey, index.PrimaryRowKey, action); }
public async Task UpdateHotWallet(string asset, string hotWallet) { var entity = await _table.GetDataAsync(AssetSettingEntity.ById.GeneratePartition(), asset); if (entity != null) { var archive = AssetSettingEntity.Archive.Create(entity); await _table.InsertAsync(archive); await _table.ReplaceAsync(AssetSettingEntity.ById.GeneratePartition(), asset, updateEntity => { updateEntity.HotWallet = hotWallet; return(updateEntity); }); } }
public Task UpdatePrice(string orderId, decimal price) { return(_storage.ReplaceAsync(OffchainOrder.GeneratePartitionKey(), orderId, order => { order.Price = price; return order; })); }
public async Task CompleteTransfer(string transferId, bool?onchain = null, string blockchainHash = null) { await _storage.ReplaceAsync(OffchainTransferEntity.ByCommon.GeneratePartitionKey(), transferId, entity => { entity.Completed = true; if (onchain != null) { entity.Onchain = onchain.Value; } if (!string.IsNullOrWhiteSpace(blockchainHash)) { entity.BlockchainHash = blockchainHash; } return(entity); }); }
public async Task UpdateAsync(AssetHedgeSettings assetHedgeSettings) { await _storage.ReplaceAsync(GetPartitionKey(), GetRowKey(assetHedgeSettings.AssetId), entity => { Mapper.Map(assetHedgeSettings, entity); return(entity); }); }
public async Task EditAssetPairAsync(IIntrinsicEventIndicatorsRow row) { var entity = await _storage.GetDataAsync(IntrinsicEventIndicatorsEntity.GeneratePartitionKeyForRow(), row.RowId); entity.PairName = row.PairName; await _storage.ReplaceAsync(entity); }
public async Task UpdateAsync(FileInfo fileInfo) { var entity = new FileInfoEntity(GetPartitionKey(fileInfo.InvoiceId), fileInfo.Id); Mapper.Map(fileInfo, entity); await _storage.ReplaceAsync(entity); }
public async Task SaveAsync(CashinAggregate aggregate) { var entity = CashinEntity.FromDomain(aggregate); await _storage.ReplaceAsync(entity); _chaosKitty.Meow(aggregate.OperationId); }
public static Task <T> ReplaceAsync <T>(this INoSQLTableStorage <T> tableStorage, IAzureIndex index, Func <T, T> action) where T : class, ITableEntity, new() { if (index == null) { return(Task.FromResult <T>(null)); } return(tableStorage.ReplaceAsync(index.PrimaryPartitionKey, index.PrimaryRowKey, action)); }
public async Task SetDisabled(string id, bool value) { await _tableStorage.ReplaceAsync(AssetEntity.GeneratePartitionKey(), AssetEntity.GenerateRowKey(id), assetEntity => { assetEntity.IsDisabled = value; return(assetEntity); }); }
public async Task UpdateAsync(IAssetCategory assetCategory) { await _assetCategoryTable.ReplaceAsync(GetPartitionKey(), GetRowKey(assetCategory.Id), x => { Mapper.Map(assetCategory, x); return(x); }); }
public async Task UpdateAsync(IIssuer issuer) { await _issuerTable.ReplaceAsync(GetPartitionKey(), GetRowKey(issuer.Id), x => { Mapper.Map(issuer, x); return(x); }); }
public async Task ReplaceAsync(IMerchant merchant) { var entity = new MerchantEntity(GetPartitionKey(merchant.Name), GetRowKey(merchant.Name)); Mapper.Map(merchant, entity); entity.ETag = "*"; await _storage.ReplaceAsync(entity); }
public Task SetDialogConditionTypeAsync(string dialogId, DialogConditionType?type) { return(_tableStorage.ReplaceAsync(ClientDialogEntity.GeneratePartitionKey(), ClientDialogEntity.GenerateRowKey(dialogId), entity => { entity.ConditionType = type; return entity; })); }
public Task ChangePasswordAsync(string id, string newPassword) { string partitionKey = BackOfficeUserEntity.GeneratePartitionKey(); string rowKey = BackOfficeUserEntity.GenerateRowKey(id); return(_tableStorage.ReplaceAsync(partitionKey, rowKey, itm => { itm.SetPassword(newPassword); return itm; })); }