public IHttpActionResult Deposit([FromBody] CreateDepositRequest request)
{
var account = _repositorywrapper.BankAccount.GetAccountById(request.Id);
if (account == null)
{
return(NotFound());
}
var IsDeposit = _repositorywrapper.BankAccount.Deposit(account.Id, request.Amount);
var transaction = _repositorywrapper.Transactions.AddTransaction(
account.AccountNumber,
request.Amount,
DateTime.Now,
account.Id,
IsDeposit ? nameof(Deposit) : "Nothing have been deposit");
var response = new TransactionReponse
{
AccountNumber = transaction.AccountNumber,
Balance = account.Balance,
Amount = transaction.Amount,
Date = transaction.Date.ToString("dd-MM-yyyy"),
BankAccountId = transaction.BankAccountId,
Action = transaction.Action
};
return(Json(response));
}
public void TestDepsosit_BalanceShouldIncreaseCorrectly()
{
//Arrange
var DepositRequest = new CreateDepositRequest()
{
Id = 1,
Balance = 0,
IBANNumber = "123451235",
AccountNumber = "123451235",
Amount = 2000,
ClearingNumber = "2134123"
};
mockService.Setup(y => y.BankAccount.GetAccountById(It.IsAny <int>())).Returns(bankAccountById);
mockService.Setup(x => x.BankAccount.Deposit(It.IsAny <int>(), It.IsAny <int>())).Returns(true);
mockService.Setup(x => x.Transactions.AddTransaction(It.IsAny <string>(), It.IsAny <int>(), It.IsAny <DateTime>(), It.IsAny <int>(), It.IsAny <string>())).Returns(new Transaction {
AccountNumber = "123451235", Date = DateTime.Now, BankAccountId = 1, Amount = 2500,
Action = "Deposit"
});
//Act
var response = accountController.Deposit(DepositRequest);
//Assert
mockService.Verify(x => x.BankAccount.GetAccountById(It.IsAny <int>()), Times.Once());
mockService.Verify(x => x.BankAccount.Deposit(It.IsAny <int>(), It.IsAny <int>()), Times.Once());
mockService.Verify(x => x.Transactions.AddTransaction(It.IsAny <string>(), It.IsAny <int>(), It.IsAny <DateTime>(), It.IsAny <int>(), It.IsAny <string>()));
var result = response.Should().BeOfType <JsonResult <TransactionReponse> >().Subject;
var account = result.Content.Should().BeAssignableTo <TransactionReponse>().Subject;
account.Balance.Should().Be(2500);
}
private async Task <CreateDeposit> CreateDepositFromLocalCurrency(CreateDepositRequest request, CancellationToken token)
{
CreateDeposit deposit = new CreateDeposit(request.AccountId, Amount.FromInput(request.Amount),
Currency.FromInput(request.Currency));
return(await Task.FromResult(deposit));
}
public async Task <IActionResult> Deposit(CreateDepositRequest request, CancellationToken token)
{
_logger.LogInformation($"{nameof(AccountController)}.{nameof(Deposit)} - {request}");
if (!ModelState.IsValid)
{
return(BadRequest($"Problem with CreateDepositRequest"));
}
if (!Currencies.IsValid(request.Currency.ToUpperInvariant()))
{
return(BadRequest($"Currency symbol entered is invalid!"));
}
CreateDeposit deposit = await CreateDepositFromLocalCurrency(request, token);
if (!_options.BaseCurrency.Equals(request.Currency, StringComparison.InvariantCultureIgnoreCase))
{
deposit = await CreateDepositFromForeignCurrency(request, token);
}
DepositResult depositResult = await _accountService.Deposit(deposit);
if (depositResult.Status == AccountStatus.Error)
{
return(BadRequest($"{depositResult.Message}"));
}
AccountDepositResponse response = new AccountDepositResponse(depositResult.AccountId,
depositResult.Amount.Value, depositResult.Currency.Value, depositResult.OldBalance.Value,
depositResult.NewBalance.Value);
return(Ok(response));
}
public async Task <HttpResponseMessage> Deposit(CreateDepositRequest request)
{
var depositRequest = JsonConvert.SerializeObject(request);
var content = new StringContent(depositRequest, Encoding.UTF8, "application/json");
var requestUrl = "http://localhost:20000/Deposit";
var result = await _httpClient.PostAsync(requestUrl, content);
return(result);
}
public async Task <HttpResponseMessage> TransferMoney(CreateDepositRequest request)
{
var transfer = JsonConvert.SerializeObject(request);
var content = new StringContent(transfer, Encoding.UTF8, "Application/json");
var requestUrl = "https://localhost:44303/api/Accounts";
var result = await _httpClient.PostAsync(requestUrl, content);
return(result);
}
private async Task <CreateDeposit> CreateDepositFromForeignCurrency(CreateDepositRequest request, CancellationToken token)
{
Rate rate = await _ratesService.GetExchangeRate(Currency.FromInput(request.Currency),
Currency.FromInput(_options.BaseCurrency),
token);
decimal convertedAmount = request.Amount * rate.ConversionValue;
CreateDeposit deposit = new CreateDeposit(request.AccountId, Amount.FromInput(convertedAmount),
Currency.FromInput(request.Currency));
return(deposit);
}
public async Task Deposit_RatesApi_Is_Invoked_Only_If_Currency_Is_Not_Base_Currency()
{
//Arrange
var dataContext = new DataContext(_dataContextOptions.Options);
IRepository <Account> accountRepository = new AccountRepository(dataContext);
IRepository <Transaction> transactionRepository = new TransactionRepository(dataContext);
IUnitOfWork unitOfWork = new UnitOfWork(dataContext, accountRepository, transactionRepository);
IGenerateId idGenerator = new IdGenerator();
CancellationToken token = new CancellationToken();
var mockRates = new Mock <IRatesService>();
mockRates.Setup(a => a.GetExchangeRate(It.IsAny <Currency>(), It.IsAny <Currency>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(() => new Rate("GBP", "GBP", 0.79m, DateTime.Now));
//Act
RatesApiOption ratesApiOption = new RatesApiOption("someurl", "USD");
IAccountService accountService =
new AccountService(_mockAccountActionLogger.Object, unitOfWork, idGenerator);
AccountCreationSummary accountCreationSummary = await accountService.CreateAccount(new CreateAccount("Jared", Amount.FromInput(100m)));
AccountController accountController = new AccountController(_mockAccountControllerLogger.Object, accountService, mockRates.Object, ratesApiOption);
CreateDepositRequest request = new CreateDepositRequest
{
AccountId = accountCreationSummary.AccountId, Amount = 30m, Currency = Currencies.EUR
};
var result = (await accountController.Deposit(request, token) as ObjectResult);
Assert.That(accountCreationSummary, Is.Not.Null);
Assert.That(accountCreationSummary.AccountId, Is.Not.Empty);
Assert.That(result, Is.Not.Null);
mockRates.Verify(a => a.GetExchangeRate(It.IsAny <Currency>(), It.IsAny <Currency>(), It.IsAny <CancellationToken>()), Times.AtLeastOnce);
}
public async Task Deposit_Fails_If_Account_Id_Is_Invalid()
{
//Arrange
var dataContext = new DataContext(_dataContextOptions.Options);
IRepository <Account> accountRepository = new AccountRepository(dataContext);
IRepository <Transaction> transactionRepository = new TransactionRepository(dataContext);
IUnitOfWork unitOfWork = new UnitOfWork(dataContext, accountRepository, transactionRepository);
IGenerateId idGenerator = new IdGenerator();
CancellationToken token = new CancellationToken();
string accountIdInvalid = "Invalid account id";
var mockRates = new Mock <IRatesService>();
mockRates.Setup(a => a.GetExchangeRate(It.IsAny <Currency>(), It.IsAny <Currency>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(() => new Rate("GBP", "GBP", 0.79m, DateTime.Now));
//Act
RatesApiOption ratesApiOption = new RatesApiOption("someurl", "USD");
IAccountService accountService =
new AccountService(_mockAccountActionLogger.Object, unitOfWork, idGenerator);
AccountController accountController = new AccountController(_mockAccountControllerLogger.Object, accountService, mockRates.Object, ratesApiOption);
CreateDepositRequest request = new CreateDepositRequest
{
AccountId = accountIdInvalid, Amount = 101m, Currency = Currencies.EUR
};
var result = (await accountController.Deposit(request, token) as ObjectResult);
Assert.That(result, Is.Not.Null);
Assert.That(result.Value, Contains.Substring("Account id not be found"));
}
public async Task <HttpResponseMessage> Transfer(CreateDepositRequest request) => await _accountServices.TransferMoney(request);
