public async Task <ActionResult <AccountModel> > AccountAsync(int accountingNumber, string accountNumber, DateTimeOffset?statusDate = null)
{
if (string.IsNullOrWhiteSpace(accountNumber))
{
throw new IntranetExceptionBuilder(ErrorCode.ValueCannotBeNullOrWhiteSpace, nameof(accountNumber))
.WithValidatingType(typeof(string))
.WithValidatingField(nameof(accountNumber))
.Build();
}
IGetAccountQuery query = new GetAccountQuery
{
AccountingNumber = accountingNumber,
AccountNumber = accountNumber,
StatusDate = statusDate?.LocalDateTime.Date ?? DateTime.Today
};
IAccount account = await _queryBus.QueryAsync <IGetAccountQuery, IAccount>(query);
if (account == null)
{
throw new IntranetExceptionBuilder(ErrorCode.ValueShouldBeKnown, nameof(accountNumber))
.WithValidatingType(typeof(string))
.WithValidatingField(nameof(accountNumber))
.Build();
}
AccountModel accountModel = _accountingModelConverter.Convert <IAccount, AccountModel>(account);
return(Ok(accountModel));
}
public async Task Throws_Bad_Request_With_Missing_Account(
GetAccountQuery query,
[Frozen] Mock <IRepository> repo,
GetAccountHandler sut)
{
repo.Setup(p => p.FindAsync(It.IsAny <IScalar <Account> >())).ReturnsAsync((Account)null);
await Assert.ThrowsAsync <BadRequestException>(async() => { await sut.Handle(query, new CancellationToken()); });
}
public async Task <IActionResult> Get(Guid accountId)
{
var query = new GetAccountQuery
{
UserId = CurrentUserId,
AccountId = accountId
};
return(Ok(await _mediator.Send(query)));
}
public async Task Returns_BadRequest_On_Invalid_ModelState(
GetAccountQuery query,
AccountsController sut)
{
sut.ModelState.AddModelError("YoBadRequest", "Something's funky, bail!");
var result = await sut.Get(query) as BadRequestObjectResult;
Assert.True(result != null);
Assert.True(result.StatusCode == 400);
}
public async Task <IActionResult> GetById([FromQuery] GetAccountQuery query)
{
var result = await _mediator.Send(query);
if (result?.Account == null)
{
return(NotFound());
}
return(Ok(result));
}
public async Task Returns_Forbidden_On_AuthorizationException(
GetAccountQuery query,
[Frozen] Mock <IMediator> mediator,
AccountsController sut)
{
mediator.Setup(p => p.Send(It.IsAny <IRequest <AccountModel> >(), It.IsAny <CancellationToken>())).ThrowsAsync(new AuthorizationException("Whoops"));
var result = await sut.Get(query) as ForbidResult;
Assert.True(result != null);
}
public async Task Returns_BadRequest_On_BadRequestException(
GetAccountQuery query,
[Frozen] Mock <IMediator> mediator,
AccountsController sut)
{
mediator.Setup(p => p.Send(It.IsAny <IRequest <AccountModel> >(), It.IsAny <CancellationToken>())).ThrowsAsync(new BadRequestException("Uh-oh"));
var result = await sut.Get(query) as BadRequestObjectResult;
Assert.True(result != null);
Assert.True(result.StatusCode == 400);
}
public async Task Returns_InternalServerError_On_Exception(
GetAccountQuery query,
[Frozen] Mock <IMediator> mediator,
AccountsController sut)
{
mediator.Setup(p => p.Send(It.IsAny <IRequest <AccountModel> >(), It.IsAny <CancellationToken>())).ThrowsAsync(new ApplicationException("Whoops"));
var result = await sut.Get(query) as ObjectResult;
Assert.True(result != null);
Assert.True(result.StatusCode == 500);
}
public async Task Then_The_Api_Is_Called_With_The_Request_And_The_Account_Is_Returned(
GetAccountQuery query,
GetAccountResponse apiResponse,
[Frozen] Mock <IAccountsApiClient <AccountsConfiguration> > apiClient,
GetAccountQueryHandler handler
)
{
apiClient.Setup(x => x.Get <GetAccountResponse>(It.Is <GetAccountRequest>(x => x.HashedAccountId == query.HashedAccountId))).ReturnsAsync(apiResponse);
var actual = await handler.Handle(query, CancellationToken.None);
actual.Should().BeEquivalentTo(apiResponse);
}
public void ThrowNotFoundException()
{
// Arrange
GetAccountQuery query = new GetAccountQuery()
{
Id = 100
};
// Act
// Assert
Assert.ThrowsAsync <NotFoundException> (() => handler.Handle(query, CancellationToken.None));
}
public async Task ReturnSingleAccountBasedOnIdSuccessfuly()
{
// Arrange
GetAccountQuery query = new GetAccountQuery()
{
Id = 10
};
// Act
var result = await handler.Handle(query, CancellationToken.None);
// Assert
Assert.Equal(10, result.Id);
Assert.IsType <AccountViewModel> (result);
}
public async Task Returns_Ok_With_Valid_Request(
GetAccountQuery query,
AccountModel model,
[Frozen] Mock <IMediator> mediator,
AccountsController sut)
{
mediator.Setup(p => p.Send(It.IsAny <IRequest <AccountModel> >(), It.IsAny <CancellationToken>())).ReturnsAsync(model);
var result = await sut.Get(query) as OkObjectResult;
Assert.True(result != null);
Assert.True(result.StatusCode == 200);
Assert.True((AccountModel)result.Value == model);
}
public void And_No_Account_Then_Throws_EntityNotFoundException(
GetAccountQuery query,
[Frozen] ValidationResult validationResult,
[Frozen] Mock <IAccountsService> mockService,
GetAccountQueryHandler handler)
{
validationResult.ValidationDictionary.Clear();
mockService
.Setup(service => service.GetAccount(It.IsAny <long>()))
.ReturnsAsync((Domain.Account.Account)null);
var act = new Func <Task>(async() => await handler.Handle(query, CancellationToken.None));
act.Should().Throw <EntityNotFoundException <Domain.Entities.Account> >();
}
public async Task Then_Gets_Account_Details_From_Service(
GetAccountQuery query,
Domain.Account.Account account,
[Frozen] ValidationResult validationResult,
[Frozen] Mock <IAccountsService> mockService,
GetAccountQueryHandler handler)
{
validationResult.ValidationDictionary.Clear();
mockService
.Setup(service => service.GetAccount(query.Id))
.ReturnsAsync(account);
var result = await handler.Handle(query, CancellationToken.None);
result.Account.Should().BeEquivalentTo(account);
}
public async Task Succeed_With_Valid_Request(
GetAccountQuery query,
Account account,
AccountModel model,
[Frozen] Mock <IReadOnlyRepository> repo,
GetAccountHandler sut)
{
model.AccountId = account.Id;
repo.Setup(p => p.FindAsync(It.IsAny <IScalar <Account> >())).ReturnsAsync(account);
var result = await sut.Handle(query, new CancellationToken());
repo.Verify(p => p.FindAsync(It.IsAny <IScalar <Account> >()), Times.Once());
Assert.True(result.AccountId == account.Id);
}
public async Task Then_If_NotFound_Response_Then_Null_Returned(
GetAccountQuery query,
[Frozen] Mock <IAccountsApiClient <AccountsConfiguration> > accountApiClient,
GetAccountQueryHandler handler)
{
//Arrange
accountApiClient.Setup(x =>
x.Get <GetAccountByIdResponse>(
It.IsAny <GetAccountByIdRequest>()))
.ReturnsAsync((GetAccountByIdResponse)null);
//Act
var actual = await handler.Handle(query, CancellationToken.None);
//Assert
actual.AccountId.Should().BeNull();
actual.HashedAccountId.Should().BeNull();
}
public async Task GetListAccount()
{
var query = new GetAccountQuery
{
UserId = new Guid("05541516-ccf1-41f4-b6ac-b2aa7d807b8c"),
CultureId = new Guid("714b19c9-7c5b-47f9-9a99-46639db1595d")
};
var result = await _handler.Execute(query);
Assert.IsNotNull(result);
Assert.AreEqual(result.AccountPresentations.Count, 1);
var account = result.AccountPresentations.First();
Assert.AreEqual(account.KeyId, new Guid("714b19c9-7c5b-47f9-9a99-46639db1595d"));
Assert.AreEqual(account.Balance, 2000);
Assert.AreEqual(account.DisplayName, "[BNK] Bank");
}
public void And_Fails_Validation_Then_Throws_ValidationException(
GetAccountQuery query,
string propertyName,
Domain.Account.Account account,
[Frozen] Mock <IValidator <GetAccountQuery> > mockValidator,
[Frozen] ValidationResult validationResult,
[Frozen] Mock <IAccountsService> mockService,
GetAccountQueryHandler handler)
{
validationResult.AddError(propertyName);
mockValidator
.Setup(validator => validator.ValidateAsync(It.IsAny <GetAccountQuery>()))
.ReturnsAsync(validationResult);
var act = new Func <Task>(async() => await handler.Handle(query, CancellationToken.None));
act.Should().Throw <ArgumentException>()
.WithMessage($"*{propertyName}*");
}
public async Task Then_The_Query_Is_Handled_And_Data_Returned(
GetAccountQuery query,
GetAccountByIdResponse apiResponse,
[Frozen] Mock <IAccountsApiClient <AccountsConfiguration> > accountsApiClient,
GetAccountQueryHandler handler)
{
//Arrange
var expectedGetUrl = new GetAccountByIdRequest(query.AccountId);
accountsApiClient
.Setup(x => x.Get <GetAccountByIdResponse>(
It.Is <GetAccountByIdRequest>(c => c.GetUrl.Equals(expectedGetUrl.GetUrl))))
.ReturnsAsync(apiResponse);
//Act
var actual = await handler.Handle(query, CancellationToken.None);
//Assert
actual.Should().BeEquivalentTo(apiResponse);
}
public async Task <IActionResult> Get([FromRoute] GetAccountQuery query)
{
return(await Execute(query));
}
public async Task <IActionResult> GetAccountById([FromRoute] Guid id)
{
var query = new GetAccountQuery(id);
return(Ok(_mapper.Map <AccountResponse>(await _bus.Send(query))));
}
public async Task <IActionResult> Get(GetAccountQuery query)
{
return(await Handle <GetAccountQuery, AccountModel>(query, Ok));
}
public async Task <IActionResult> GetAccountDetail([FromBody] GetAccountRequest request)
{
try
{
_logger.LogInformation("Get account number(Account Number: {AccountNumber}) with account type {AccountType}.", request.AccountNumber, request.AccountPIN);
//validate parameters
if (request.AccountNumber.Length == 0)
{
_logger.LogInformation("No account number found from request.");
return(new JsonResult(new GetAccountResponse()
{
StatusCode = Convert.ToInt32(HttpStatusCode.OK),
Message = Convert.ToString(HttpStatusCode.OK),
Payload = new GetAccountResponsePayload()
{
MessageDetail = "No account number found."
}
}));
}
if (request.AccountPIN.Length == 0)
{
_logger.LogInformation("No account PIN found from request.");
return(new JsonResult(new GetAccountResponse()
{
StatusCode = Convert.ToInt32(HttpStatusCode.OK),
Message = Convert.ToString(HttpStatusCode.OK),
Payload = new GetAccountResponsePayload()
{
MessageDetail = "No account PIN found."
}
}));
}
//call query handler
var query = new GetAccountQuery(request.AccountNumber, request.AccountPIN);
var queryResult = await _mediator.Send(query);
return(new JsonResult(new GetAccountResponse()
{
StatusCode = queryResult.StatusCode,
Message = queryResult.Message,
MessageDetail = queryResult.MessageDetails,
Payload = new GetAccountResponsePayload()
{
AcctId = queryResult.AcctId,
FirstName = queryResult.FirstName,
MiddleName = queryResult.MiddleName,
LastName = queryResult.LastName,
AccountNumber = queryResult.AccountNumber,
AccountPIN = queryResult.AccountPIN,
AccountType = queryResult.AccountType,
AccountStatus = queryResult.AccountStatus,
InitialAmountDeposit = queryResult.InitialAmountDeposit,
DateCreated = queryResult.DateCreated,
DateUpdated = queryResult.DateUpdated,
MessageDetail = queryResult.MessageDetails
}
}));
}
catch (Exception ex)
{
_logger.LogError("Get account number request failed. Exception error message: {exceptionMessage}", ex.ToString());
return(new JsonResult(new GetAccountResponse()
{
StatusCode = Convert.ToInt32(HttpStatusCode.BadRequest),
Message = Convert.ToString(HttpStatusCode.BadRequest),
MessageDetail = "Get contact group list request failed. Exception error message: " + ex.ToString()
}));
}
}
public async Task <GetAccountQuery.Result> Account([FromUri] GetAccountQuery query)
{
return(await _queryDispatcher.Execute <GetAccountQuery, GetAccountQuery.Result>(query));
}
