public async Task <Book> Handle(GetBookQuery request, CancellationToken cancellationToken)
{
using (var connection = _connectionFactory.Create())
{
var query = $@"Select b.Id, b.Name, b.Picture, b.Date, b.Summary, b.Rate,
a.Id, a.Name as FirstName, a.SurName as LastName, a.DateOfBirth, a.DateOfDeath
from dbo.BookAuthorEntity as ba
inner join dbo.Books as b on ba.BookId = b.Id
inner join dbo.Authors as a on ba.AuthorId = a.Id
where b.Id = @BookId";
var authors = new List <Author>();
var res = await connection.QueryAsync <Book, Author, Book>(
query,
(book, author) =>
{
authors.Add(author);
return(book);
},
new { BookId = request.BookId }
);
var foundBook = res.First();
foundBook.Authors = authors;
return(foundBook);
}
}
public IHttpActionResult AddNewBookToStore([FromBody] NewBook newBook)
{
if (!ModelState.IsValid)
{
return(new InvalidModelResult(Request, HttpStatusCode.BadRequest, ModelState));
}
var command = new AddNewBookCommand(newBook);
if (!command.IsValidCommand())
{
return(BadRequest());
}
_addNewBookToStoreUseCase.Handle(command);
var query = new GetBookQuery(newBook.Isbn);
var result = _getBookInfoWithDetailsUseCase.Handle(query);
if (result != null)
{
return(Created(result.Links.First(x => x.Rel == "self").Href, result));
}
return(NotFound());
}
public async Task <ActionResult <BookModel> > GetBook(Guid bookId)
{
var query = new GetBookQuery {
BookId = bookId
};
var book = await _mediator.Send(query);
return(Ok(book));
}
public async Task <GetBookQueryResponse> GetBookAsync(GetBookQuery bookQuery)
{
var book = await _bookDbContext.Books
.AsNoTracking()
.ProjectTo <GetBookQueryResponse>(_mapper.ConfigurationProvider)
.FirstOrDefaultAsync(x => x.Id == bookQuery.Id);
return(book);
}
public async Task <IActionResult> GetBook([FromQuery] Guid id)
{
var query = new GetBookQuery {
BookId = id
};
var response = await mediator.Send(query);
return(Ok(response));
}
public async Task <IActionResult> GetBook(Guid id)
{
var query = new GetBookQuery {
BookId = id
};
var result = await _mediator.Send(query);
return(Ok(result));
}
public async Task <BookModel> GetBook(GetBookQuery query)
{
var url = $"books/{query.BookId}";
using var response = await _httpClient.GetAsync(url);
var book = await SafelyReadFromJsonAsync <BookModel>(response);
book.Id.Should().Be(query.BookId);
return(book);
}
private BookDto Handle(GetBookQuery query)
{
var provider = DependencyInjectorStub.Get((s, c) =>
{
BootStrapper.RegisterServices(s, c);
s.AddScoped(x => MockRepository.GetContext());
});
var handler = provider.GetRequiredService <IRequestHandler <GetBookQuery, BookDto> >();
return(handler.Handle(query, CancellationToken.None).GetAwaiter().GetResult());
}
public IHttpActionResult GetBookBaseInfo([FromUri] int bookId)
{
if (!Validators.IsIdValid(bookId))
{
return(BadRequest());
}
var query = new GetBookQuery(bookId);
var result = _getBookBaseInfoUseCase.Handle(query);
if (result != null)
{
return(Ok(result));
}
return(NotFound());
}
public IActionResult GetBook(Guid id)
{
if (ModelState.IsValid)
{
GetBookQuery getBookQuery = new GetBookQuery(id);
try
{
var result = _messages.Dispatch(getBookQuery);
return(Ok(result));
}
catch (DomainException ex)
{
_logger.LogError(ex.Message);
return(Error(ex.Message));
}
catch (Exception ex)
{
_logger.LogCritical(ex.Message);
return(StatusCode(500));
}
}
return(BadRequest());
}
public async Task <ActionResult <GetBookResponse> > GetBookAsync(GetBookQuery query)
{
return(await Mediator.Send(query));
}
public async Task <IActionResult> GetBook(GetBookQuery getBookQuery)
{
var book = await mediator.Send(getBookQuery, HttpContext.RequestAborted).ConfigureAwait(false);
return(book != null?Ok(book) : (IActionResult)NotFound());
}
public async Task <IActionResult> Get([FromQuery] GetBookQuery query)
{
var result = await _mediator.Send(query);
return(Ok(result));
}
public async Task <IActionResult> GetBook([FromQuery] GetBookQuery query)
{
var book = await _mediator.Send(query, this.HttpContext.RequestAborted);
return(Ok(book));
}
