public CashoutRiskControlAggregate ToDomain()
{
return(CashoutRiskControlAggregate.Restore(
ETag,
State,
Result,
CreationMoment,
StartMoment,
OperationAcceptanceMoment,
OperationRejectionMoment,
OperationId,
ClientId,
AssetId,
BlockchainType,
BlockchainAssetId,
HotWalletAddress,
ToAddress,
Amount,
Error));
}
public async Task Handle(ValidationStartedEvent evt, ICommandSender sender)
{
var aggregate = await _riskControlRepository.GetOrAddAsync(
evt.OperationId,
() => CashoutRiskControlAggregate.Create(
evt.OperationId,
evt.ClientId,
evt.AssetId,
evt.BlockchainType,
evt.BlockchainAssetId,
evt.HotWalletAddress,
evt.ToAddress,
evt.Amount));
_chaosKitty.Meow(evt.OperationId);
if (aggregate.Start())
{
sender.SendCommand
(
new ValidateOperationCommand
{
OperationId = evt.OperationId,
UserId = evt.ClientId,
Type = OperationType.Withdrawal,
BlockchainAssetId = evt.BlockchainAssetId,
BlockchainType = evt.BlockchainType,
FromAddress = evt.HotWalletAddress,
ToAddress = evt.ToAddress,
Amount = evt.Amount
},
BlockchainRiskControlBoundedContext.Name
);
_chaosKitty.Meow(evt.OperationId);
await _riskControlRepository.SaveAsync(aggregate);
_chaosKitty.Meow(evt.OperationId);
}
}
public static CashoutRiskControlEntity FromDomain(CashoutRiskControlAggregate aggregate)
{
return(new CashoutRiskControlEntity
{
ETag = string.IsNullOrEmpty(aggregate.Version) ? "*" : aggregate.Version,
PartitionKey = GetPartitionKey(aggregate.OperationId),
RowKey = GetRowKey(),
State = aggregate.State,
Result = aggregate.Result,
CreationMoment = aggregate.CreationMoment,
StartMoment = aggregate.StartMoment,
OperationAcceptanceMoment = aggregate.OperationAcceptanceMoment,
OperationRejectionMoment = aggregate.OperationRejectionMoment,
OperationId = aggregate.OperationId,
ClientId = aggregate.ClientId,
AssetId = aggregate.AssetId,
BlockchainType = aggregate.BlockchainType,
BlockchainAssetId = aggregate.BlockchainAssetId,
HotWalletAddress = aggregate.HotWalletAddress,
ToAddress = aggregate.ToAddress,
Amount = aggregate.Amount,
Error = aggregate.Error
});
}
public RiskControlSagaTests()
{
_logFactory = LogFactory.Create().AddUnbufferedConsole();
_chaosKittyMock = new Mock <IChaosKitty>();
_eventsPublisherMock = new Mock <IEventPublisher>();
_commandSender = new Mock <ICommandSender>();
_cashoutRiskControlRepositoryMock = new Mock <ICashoutRiskControlRepository>();
_batchRepositoryMock = new Mock <ICashoutsBatchRepository>();
_closedBatchedCashoutsRepositoryMock = new Mock <IClosedBatchedCashoutRepository>();
_activeCashoutsBatchIdRepositoryMock = new Mock <IActiveCashoutsBatchIdRepository>();
_assetsServiceMock = new Mock <IAssetsServiceWithCache>();
_walletsClientMock = new Mock <IBlockchainWalletsClient>();
_cqrsSettings = new CqrsSettings
{
RabbitConnectionString = "fake-connection-string",
RetryDelay = TimeSpan.FromSeconds(30)
};
_blockchainConfigurationProvider = new BlockchainConfigurationsProvider
(
_logFactory,
new Dictionary <string, BlockchainConfiguration>
{
{ "Bitcoin", new BlockchainConfiguration("HotWallet", false, null) }
}
);
_asset = new Asset
{
Id = "LykkeBTC",
BlockchainIntegrationLayerId = "Bitcoin",
BlockchainIntegrationLayerAssetId = "BTC"
};
_aggregate = null;
_cashoutRiskControlRepositoryMock
.Setup(x => x.GetOrAddAsync(
It.IsAny <Guid>(),
It.IsAny <Func <CashoutRiskControlAggregate> >()))
.ReturnsAsync((Guid opId, Func <CashoutRiskControlAggregate> factory) => _aggregate ?? (_aggregate = factory()));
_cashoutRiskControlRepositoryMock
.Setup(x => x.SaveAsync(It.IsAny <CashoutRiskControlAggregate>()))
.Callback((CashoutRiskControlAggregate agg) => _aggregate = agg)
.Returns(Task.CompletedTask);
_cashoutRiskControlRepositoryMock
.Setup(x => x.TryGetAsync(It.IsAny <Guid>()))
.ReturnsAsync((Guid opId) => opId == _aggregate?.OperationId ? _aggregate : null);
_assetsServiceMock
.Setup(x => x.TryGetAssetAsync(
It.Is <string>(p => p == "LykkeBTC"),
It.IsAny <CancellationToken>()))
.ReturnsAsync(() => _asset);
_walletsClientMock
.Setup(x => x.TryGetClientIdAsync(
It.Is <string>(p => p == "Bitcoin"),
It.IsAny <string>()))
.ReturnsAsync((Guid?)null);
_startCashoutCommandsHandler = new StartCashoutCommandsHandler(_logFactory, _blockchainConfigurationProvider, _assetsServiceMock.Object, new Mock <IHttpClientFactory>().Object);
_notifyCashoutFailedCommandsHandler = new NotifyCashoutFailedCommandsHandler();
_acceptCashoutCommandsHandler = new AcceptCashoutCommandsHandler(
_chaosKittyMock.Object,
_batchRepositoryMock.Object,
_closedBatchedCashoutsRepositoryMock.Object,
_activeCashoutsBatchIdRepositoryMock.Object,
_blockchainConfigurationProvider,
_walletsClientMock.Object,
_cqrsSettings,
false);
_saga = new RiskControlSaga(_chaosKittyMock.Object, _cashoutRiskControlRepositoryMock.Object);
_eventsPublisherMock.Setup(x => x.PublishEvent(It.IsAny <ValidationStartedEvent>()))
.Callback((object evt) => _saga.Handle((ValidationStartedEvent)evt, _commandSender.Object));
_eventsPublisherMock.Setup(x => x.PublishEvent(It.IsAny <OperationAcceptedEvent>()))
.Callback((object evt) => _saga.Handle((OperationAcceptedEvent)evt, _commandSender.Object));
_eventsPublisherMock.Setup(x => x.PublishEvent(It.IsAny <OperationRejectedEvent>()))
.Callback((object evt) => _saga.Handle((OperationRejectedEvent)evt, _commandSender.Object));
_commandSender
.Setup(x => x.SendCommand(
It.IsAny <AcceptCashoutCommand>(),
It.Is <string>(v => v == BlockchainCashoutProcessorBoundedContext.Name),
It.IsAny <uint>()))
.Callback((AcceptCashoutCommand cmd, string bc, uint _) => _acceptCashoutCommandsHandler.Handle(cmd, _eventsPublisherMock.Object));
_commandSender
.Setup(x => x.SendCommand(
It.IsAny <NotifyCashoutFailedCommand>(),
It.Is <string>(v => v == BlockchainCashoutProcessorBoundedContext.Name),
It.IsAny <uint>()))
.Callback((NotifyCashoutFailedCommand cmd, string bc, uint _) => _notifyCashoutFailedCommandsHandler.Handle(cmd, _eventsPublisherMock.Object));
}
public async Task SaveAsync(CashoutRiskControlAggregate aggregate)
{
var entity = CashoutRiskControlEntity.FromDomain(aggregate);
await _storage.ReplaceAsync(entity);
}