public async Task <DepositWalletLock> LockAsync(
DepositWalletKey key,
decimal balance,
long block,
Func <Guid> operationIdFactory)
{
var partitionKey = DepositWalletLockEntity.GetPartitionKey(key);
var rowKey = DepositWalletLockEntity.GetRowKey(key);
var entity = await _storage.GetOrInsertAsync
(
partitionKey,
rowKey,
// ReSharper disable once ImplicitlyCapturedClosure
() => DepositWalletLockEntity.Create
(
key,
balance,
block,
operationIdFactory()
)
);
return(DepositWalletLock.Create(key, entity.OperationId, entity.Balance, entity.Block));
}
public async Task <OperationAggregate> GetOrInsert(Guid operationId, Func <OperationAggregate> factory)
{
var rowKey = OperationEntity.GenerateRowKey();
var partitionKey = OperationEntity.GeneratePartitionKey(operationId);
return((await _storage.GetOrInsertAsync(partitionKey, rowKey, () => OperationEntity.FromDomain(factory())))
.ToDomain());
}
public async Task <Guid> GetOperationIdAsync(long depositId)
{
var entity = await _tableStorage.GetOrInsertAsync(OperationIdEntity.GetPk(depositId),
OperationIdEntity.GetRk(depositId),
() => OperationIdEntity.Create(depositId));
return(Guid.Parse(entity.OperationId));
}
public async Task <string> GetKey(string clientId, string key)
{
var entity = await _tableStorage.GetOrInsertAsync(
ClientKeysToBlobKeyEntity.GetPartitionKey(clientId),
ClientKeysToBlobKeyEntity.GetRowKey(key),
() => ClientKeysToBlobKeyEntity.Create(clientId, key, Guid.NewGuid().ToString()));
return(entity.BlobKey);
}
public async Task <IOperationExecutionInfo <TData> > GetOrAddAsync <TData>(string operationName, string operationId,
Func <IOperationExecutionInfo <TData> > factory) where TData : class
{
var entity = await _tableStorage.GetOrInsertAsync(
OperationExecutionInfoEntity.GeneratePartitionKey(operationName),
OperationExecutionInfoEntity.GeneratePartitionKey(operationId),
() => Convert(factory()));
return(Convert <TData>(entity));
}
public async Task <bool> TryLockAsync(Guid owner)
{
var partition = GeneratePartitionKey();
var row = GenerateRowKey();
return((await _storage.GetOrInsertAsync(partition, row, () => new DistriibutedLockEntity
{
PartitionKey = partition,
RowKey = row,
Owner = owner
})).Owner == owner);
}
public async Task <bool> TryGetLockAsync(string blockchainType, string address, Guid transactionId)
{
var partitionKey = SourceAddressLockEntity.GetPartitionKey(blockchainType, address);
var rowKey = SourceAddressLockEntity.GetRowKey(address);
var lockEntity = await _storage.GetOrInsertAsync(partitionKey, rowKey,
() => new SourceAddressLockEntity
{
PartitionKey = partitionKey,
RowKey = rowKey,
OwnerTransactionId = transactionId
});
return(lockEntity.OwnerTransactionId == transactionId);
}
public async Task <IOperationExecutionInfo <TData> > GetOrAddAsync <TData>(
string operationName, string operationId, Func <IOperationExecutionInfo <TData> > factory) where TData : class
{
var entity = await _tableStorage.GetOrInsertAsync(
partitionKey : OperationExecutionInfoEntity.GeneratePartitionKey(operationName),
rowKey : OperationExecutionInfoEntity.GeneratePartitionKey(operationId),
createNew : () =>
{
var result = Convert(factory());
result.LastModified = _systemClock.UtcNow.UtcDateTime;
return(result);
});
return(Convert <TData>(entity));
}
public async Task <string> MapAsync(string clinetId, string requestId)
{
var id = Guid.NewGuid().ToString();
var entity = await _tableStorage.GetOrInsertAsync(
clinetId,
requestId,
() => new IdMappingEntity
{
PartitionKey = clinetId,
RowKey = requestId,
Id = id
});
return(entity.Id);
}
public async Task <Guid> GetOrStartTransactionAsync(Guid operationId, Func <Guid> newTransactionIdFactory)
{
var partitionKey = ActiveTransactionEntity.GetPartitionKey(operationId);
var rowKey = ActiveTransactionEntity.GetRowKey(operationId);
var entity = await _storage.GetOrInsertAsync(
partitionKey,
rowKey,
() => new ActiveTransactionEntity
{
PartitionKey = partitionKey,
RowKey = rowKey,
TransactionId = newTransactionIdFactory()
});
return(entity.TransactionId);
}
public async Task <CashoutRiskControlAggregate> GetOrAddAsync(Guid operationId, Func <CashoutRiskControlAggregate> newAggregateFactory)
{
var partitionKey = CashoutRiskControlEntity.GetPartitionKey(operationId);
var rowKey = CashoutRiskControlEntity.GetRowKey();
var startedEntity = await _storage.GetOrInsertAsync(
partitionKey,
rowKey,
() =>
{
var newAggregate = newAggregateFactory();
return(CashoutRiskControlEntity.FromDomain(newAggregate));
});
return(startedEntity.ToDomain());
}
public async Task <bool> TryLockAsync(string assetId, Guid operationId, DateTime lockedAt)
{
var partitionKey = CashoutLockEntity.GetPartitionKey(assetId);
var rowKey = CashoutLockEntity.GetRowKey(assetId);
var lockEntity = await _storage.GetOrInsertAsync(partitionKey, rowKey,
() => new CashoutLockEntity
{
PartitionKey = partitionKey,
RowKey = rowKey,
OperationId = operationId,
AssetId = assetId,
LockedAt = lockedAt
});
return(lockEntity?.OperationId == operationId);
}
public async Task <TAggregate> GetOrAddAsync(Guid aggregateId, Func <TAggregate> newAggregateFactory)
{
var partitionKey = AggregateKeysBuilder.BuildPartitionKey(aggregateId);
var rowKey = AggregateKeysBuilder.BuildRowKey(aggregateId);
var startedEntity = await _storage.GetOrInsertAsync(
partitionKey,
rowKey,
() =>
{
var newAggregate = newAggregateFactory();
return(_mapAggregateToEntity(newAggregate));
});
return(await _mapEntityToAggregate(startedEntity));
}
public async Task <EthereumCashinAggregate> GetOrAddAsync(string trHash, Func <EthereumCashinAggregate> newAggregateFactory)
{
var partitionKey = EthereumCashinAggregateEntity.GetPartitionKey(trHash);
var rowKey = EthereumCashinAggregateEntity.GetRowKey(trHash);
var startedEntity = await _storage.GetOrInsertAsync(
partitionKey,
rowKey,
() =>
{
var newAggregate = newAggregateFactory();
return(EthereumCashinAggregateEntity.FromDomain(newAggregate));
});
return(startedEntity.ToDomain());
}
public async Task <BlackListModel> GetOrAddAsync(string blockchainType, string blockedAddress, Func <BlackListModel> newAggregateFactory)
{
var partitionKey = BlackListEntity.GetPartitionKey(blockchainType);
var rowKey = BlackListEntity.GetRowKey(blockedAddress);
var startedEntity = await _storage.GetOrInsertAsync(
partitionKey,
rowKey,
() =>
{
var newAggregate = newAggregateFactory();
return(BlackListEntity.FromDomain(newAggregate));
});
return(startedEntity.ToDomain());
}
public async Task <Guid> GetOrCreateCashInOutIdAsync(
string clientId,
string assetId)
{
var migration = await _migrations.GetOrInsertAsync
(
clientId,
assetId,
() => new MigrationEntity
{
CashInOutId = Guid.NewGuid(),
PartitionKey = clientId,
RowKey = assetId
}
);
return(migration.CashInOutId);
}
public async Task <CashinAggregate> GetOrAddAsync(
string blockchainType,
string depositWalletAddress,
string blockchainAssetId,
Guid operationId,
Func <CashinAggregate> newAggregateFactory)
{
var partitionKey = CashinEntity.GetPartitionKey(operationId);
var rowKey = CashinEntity.GetRowKey(operationId);
var startedEntity = await _storage.GetOrInsertAsync(
partitionKey,
rowKey,
() =>
{
var newAggregate = newAggregateFactory();
return(CashinEntity.FromDomain(newAggregate));
});
return(startedEntity.ToDomain());
}
public async Task <ActiveCashoutBatchId> GetActiveOrNextBatchId(string blockchainType, string blockchainAssetId, string hotWallet, Func <Guid> getNextId)
{
var partitionKey = ActiveCashoutsBatchIdEntity.GeneratePartitionKey(blockchainType);
var rowKey = ActiveCashoutsBatchIdEntity.GenerateRowKey(blockchainAssetId, hotWallet);
var entity = await _storage.GetOrInsertAsync(
partitionKey,
rowKey,
() =>
{
var id = getNextId();
return(ActiveCashoutsBatchIdEntity.FromDomain
(
blockchainType,
blockchainAssetId,
hotWallet,
id
));
});
return(entity.ToDomain());
}
