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;
}));
}
