public async Task <CustomerViewModel> GetById(Guid id)
{
var customerQuery = new GetCustomerByIdQuery(id);
var customer = await Bus.GetQuery <Customer, GetCustomerByIdQuery>(customerQuery);
return(_mapper.Map <CustomerViewModel>(customer));
}
public async Task <IActionResult> GetCustomer(Guid customerId)
{
var query = new GetCustomerByIdQuery(customerId);
var result = await _mediator.Send(query);
return(result != null ? (IActionResult)Ok(result) : NotFound());
}
public async Task <(float response, string message, bool isSuccess)> GetTotalInvoice(long customerId, CancellationToken cancellationToken)
{
var customerDetailsQuery = new GetCustomerByIdQuery(customerId);
var customerDetails = await _mediator.Send(customerDetailsQuery);
if (!customerDetails.isSuccess)
{
return(0f, $"Unable to complete request \n{customerDetails.message}", false);
}
var customerOrdersQuery = new GetAllOrdersByCustomerIdQuery(customerId);
var customerOrders = await _mediator.Send(customerOrdersQuery);
if (!customerOrders.isSuccess)
{
return(0f, $"Unable to complete request \n{customerOrders.message}", false);
}
var discountsQuery = new GetAllDiscountsQuery();
var discounts = await _mediator.Send(discountsQuery);
if (!discounts.isSuccess)
{
return(0f, $"Unable to complete request \n{discounts.message}", false);
}
var discountManager = new DiscountManager(customerDetails, customerOrders, discounts);
var totalInvoiceWithDiscount = discountManager.GetDiscountedTotal();
return(totalInvoiceWithDiscount, "Success", true);
}
static void Main(string[] args)
{
var getCustomerQuery = new GetCustomerByIdQuery {
Id = Guid.Parse("4AC1E4A4-8031-4D66-BDB1-0FDCBB9B4443")
};
var customer = getCustomerQuery.SendQuery <GetCustomerByIdQuery, Customer>(getCustomerQuery);
}
public async Task ShouldReturnNullIfCustomerDoesntExist()
{
var command = new GetCustomerByIdQuery(-1);
var handler = new GetCustomerByIdQueryHandler(_mapper, _customerReadOnlyRepository);
var result = await handler.Handle(command, CancellationToken.None);
Assert.IsTrue(result == null);
}
public async Task <IActionResult> GetAsync(int id)
{
var query = new GetCustomerByIdQuery(id);
var result = await _mediator.Send(query);
return(result != null ? (IActionResult)Ok(result) : NotFound());
//return $"Catcher Wong - {id} - {Request.Host.Port}";
}
public GetByIdCustomerHandlerTests()
{
_customer = _fixture.Create <Entity.Concrete.Customer>();
_customerIdQuery = _fixture.Create <GetCustomerByIdQuery>();
_customerResponse = new Mock <GetCustomerByIdQueryResponse>();
_customerDataResponse = new Mock <IDataResult <GetCustomerByIdQueryResponse> >();
_mapper = new Mock <IMapper>();
_repository = new Mock <IGenericRepository <Entity.Concrete.Customer> >();
_sut = new GetCustomerByIdHandlers(_repository.Object, _mapper.Object);
}
public Task <Customer> Handle(GetCustomerByIdQuery request, CancellationToken cancellationToken)
{
var entity = _context.Customers.Find(request.Id);
if (entity != null)
{
return(Task.FromResult(entity));
}
return(Task.FromResult(default(Customer)));
}
public async Task Handle_GivenInvalidRequest_ShouldThrowNotFoundException()
{
// Arrange
var query = new GetCustomerByIdQuery {
Id = 1000
};
var sut = new GetCustomerByIdQueryHandler(this.deletableEntityRepository);
// Act & Assert
await Should.ThrowAsync <NotFoundException>(sut.Handle(query, It.IsAny <CancellationToken>()));
}
public async Task ShouldReturnOneCustomer()
{
var command = new GetCustomerByIdQuery(1);
var handler = new GetCustomerByIdQueryHandler(_mapper, _customerReadOnlyRepository);
var result = await handler.Handle(command, CancellationToken.None);
var customer = await _customerReadOnlyRepository.GetById(1);
Assert.IsTrue(result != null);
Assert.IsTrue(customer.Email == result.Email);
}
public void TestGetCustomerByIdQuery()
{
GetCustomerByIdQuery query = new GetCustomerByIdQuery
{
SearchInput = GetCustomerByIdQuery.Criteria.SearchById(2)
};
IList <Customer> resultsById = query.Execute();
Customer matchById = resultsById.First();
Assert.AreEqual("2", matchById.Number);
Assert.AreEqual("Jane Doe", matchById.Name);
}
public IHttpActionResult GetCustomerById(string customerNumber, CancellationToken cancellationToken)
{
var request = new GetCustomerByIdQuery
{
CustomerId = customerNumber
};
var response = mediator.Send(request, cancellationToken);
var contract = mapper.Map <CustomerDetailsContract>(response.Result);
return(Ok(contract));
}
public async Task Test_ForNonExistingCustomer_ShouldReturnNull()
{
var mock = new Mock <ICustomerRepository>();
mock.Setup(foo => foo.GetById(1)).Returns((Customer)null);
var query = new GetCustomerByIdQuery(1);
var queryHandler = new GetCustomerByIdQueryHandler(mock.Object);
// Act
var result = await queryHandler.Handle(query, CancellationToken.None);
// Assert
Assert.Null(result);
}
public async Task <ActionResult <GetCustomerByIdQueryResult> > GetCustomerById([FromRoute] Guid id, CancellationToken cancellationToken)
{
var query = new GetCustomerByIdQuery {
Id = id
};
var result = await Mediator.Send(query, cancellationToken);
if (result?.Customer == null)
{
return(NotFound());
}
return(Ok(result));
}
public async Task <IActionResult> OnGetAsync(int id)
{
var query = new GetCustomerByIdQuery {
Id = id
};
Customer = await _mediator.Send(query);
if (Customer == null)
{
return(RedirectToPage("./Index"));
}
return(Page());
}
public async Task Handle_GivenValidRequest_ShouldReturnEditMainCategoryCommand()
{
// Arrange
var query = new GetCustomerByIdQuery {
Id = 1
};
var sut = new GetCustomerByIdQueryHandler(this.deletableEntityRepository);
// Act
var customer = await sut.Handle(query, It.IsAny <CancellationToken>());
customer.ShouldNotBeNull();
customer.ShouldBeOfType <CustomerLookupModel>();
customer.FirstName.ShouldBe("John");
}
public async Task <IActionResult> GetCustomerById([FromQuery] long customerId)
{
var query = new GetCustomerByIdQuery(customerId);
var result = await _mediator.Send(query);
if (result.isSuccess)
{
return(Ok(new ApiResponse
{
ResponseCode = "00",
ResponseDescription = result.message,
Data = result.response
}));
}
return(NotFound(new ApiResponse {
ResponseCode = "01", ResponseDescription = result.message, Data = null
}));
}
public async Task <Customer> ObterPorId(int id)
{
try
{
var query = new GetCustomerByIdQuery {
Id = id
};
Log.Information($"Buscando cliente com id: {id}");
var result = await _mediatR.Send(query);
Log.Information($"Cliente com id: {id} foi encontrando com sucesso.");
return(result);
}
catch (Exception ex)
{
Log.Error($"Não foi possível encontrar o cliente com id: {id} - {ex.StackTrace}");
throw;
}
}
public async Task ShouldReturnNullIfCustomerDoesntExist()
{
//Arrange
Customer expected = null;
_customerReadOnlyRepository.Setup(x =>
x.GetById(It.IsAny <int>()))
.Returns(Task.FromResult(expected))
.Verifiable();
//Act
var command = new GetCustomerByIdQuery(1);
var handler = new GetCustomerByIdQueryHandler(_mapper, _customerReadOnlyRepository.Object);
//Assert
var result = await handler.Handle(command, CancellationToken.None);
Assert.Null(result);
_customerReadOnlyRepository.Verify(x => x.GetById(It.IsAny <int>()), Times.Once);
}
public async Task Test_ForExistingCustomer_ShouldReturnCustomer()
{
// Arrange
var mock = new Mock <ICustomerRepository>();
var customer = Fixture.Create <Customer>();
mock.Setup(foo => foo.GetById(customer.Id)).Returns(customer);
var query = new GetCustomerByIdQuery(customer.Id);
var queryHandler = new GetCustomerByIdQueryHandler(mock.Object);
// Act
var result = await queryHandler.Handle(query, CancellationToken.None);
// Assert
Assert.NotNull(result);
Assert.Equal(customer.Id, result.Id);
Assert.Equal(customer.Name, result.Name);
Assert.Equal(customer.Address, result.Address);
Assert.Equal(customer.Email, result.Email);
Assert.Equal(customer.DateBirth, result.DateBirth, new TimeSpan(1, 0, 0, 0));
}
public async Task ShouldReturnOneCustomer()
{
//Arrange
Customer expected = new Customer()
{
Email = "*****@*****.**", Age = 25
};
_customerReadOnlyRepository.Setup(x =>
x.GetById(It.IsAny <int>()))
.Returns(Task.FromResult(expected));
var command = new GetCustomerByIdQuery(1);
var handler = new GetCustomerByIdQueryHandler(_mapper, _customerReadOnlyRepository.Object);
//Act
var result = await handler.Handle(command, CancellationToken.None);
//Assert
Assert.NotNull(result);
Assert.Equal("*****@*****.**", result.Email);
}
public async Task <IActionResult> Get([FromRoute] GetCustomerByIdQuery request)
{
return(Ok(await _mediator.Send(request)));
}
public async Task <CustomerDTO> GetCustomerAsync(int id)
{
var query = new GetCustomerByIdQuery(id);
return(await _mediator.Send(query));
}
public async Task <IResult <Models.Customer> > Handle(GetCustomerByIdQuery request, CancellationToken cancellationToken)
{
return(await customerService.GetByIdAsync(request.CustomerId));
}
public async Task <IActionResult> GetCustomerById([FromQuery] int id)
{
var query = new GetCustomerByIdQuery(id);
return(Ok(await queryExecutor.Execute(query)));
}
public async Task <CustomerViewModel> GetById(int id)
{
var getByIdCommand = new GetCustomerByIdQuery(id);
return(await _mediator.Send(getByIdCommand));
}
public GetCustomerController(GetCustomerByIdQuery query)
{
_query = query;
}
