Example #1
0
        public async Task MakeTransfer(MakeTransferCommand command, CancellationToken cancellationToken = default)
        {
            // get both source and destiny accounts
            var account = await _accountRepository.GetOneAsync(new GetAccountSpecification(command.SourceAccountId), cancellationToken);

            if (account == null)
            {
                throw new ArgumentNullException(nameof(account));
            }

            var relatedAccount = await _accountRepository.GetOneAsync(new GetAccountSpecification(command.DestinyAccountId), cancellationToken);

            if (relatedAccount == null)
            {
                throw new ArgumentNullException(nameof(relatedAccount));
            }

            if (account.Id == relatedAccount.Id)
            {
                throw new InvalidOperationException("it is not possible make transfer to same account.");
            }

            // make the transfer between accounts
            var debitEntry = account.Transfer(relatedAccount, command.Value);

            // reflect as a deposit in related account
            var creditEntry = relatedAccount.Deposit(account, command.Value);

            // save updated accounts with theirs new entries
            _accountRepository.Update(new[] { account, relatedAccount });
            await _accountRepository.SaveChangesAsync();

            // save new entries to the blockchain
            await AddEntryToBlockchain(new[] { debitEntry, creditEntry });
        }
Example #2
0
        public async Task <IActionResult> MakeTransfer([FromRoute] int id, [FromBody] MakeTransferCommand command, CancellationToken cancellation = default)
        {
            try
            {
                command = new MakeTransferCommand(id, command.DestinyAccountId, command.Value);
                await _accountAppService.MakeTransfer(command, cancellation);

                return(NoContent());
            }
            catch (Exception ex)
            {
                return(StatusCode(500, ex));
            }
        }
        public async Task <IActionResult> MakeTransfer([FromBody] TransferDto data)
        {
            var userId = userManager.GetUserId(User);

            var command = new MakeTransferCommand
            {
                UserId      = userId,
                Transaction = data
            };

            var commandResult = await mediator.Send(command);

            if (!commandResult.IsSuccessful)
            {
                return(BadRequest());
            }

            return(Ok());
        }
        public async Task MakeTransferUnsuccesfulByAmount()
        {
            var sut = new MakeTransferCommandHandler(context);

            var command = new MakeTransferCommand
            {
                UserId      = "test_user_id",
                Transaction = new Shared.TransferDto
                {
                    SourceId = wallet_id_one,
                    TargetId = wallet_id_two,
                    Username = "******",
                    Amount   = 150,
                }
            };

            var result = await sut.Handle(command, CancellationToken.None);

            Assert.IsFalse(result.IsSuccessful);
        }