public async void ShouldReturnAllBooksFromTheRepository()
{
// Arrange
var bookToCreate = new Book
{
Title = "The wind in the willows",
ISBN10 = "1515151515"
};
var createdId = await _fixture.AddAsync(bookToCreate);
var query = new GetBooksQuery();
// Act
var result = await _fixture.SendAsync(query);
// Assert
result.ShouldNotBeNull();
result.Count.ShouldBeGreaterThan(0);
var createdBook = result.Single(x => x.Id == createdId);
createdBook.ShouldNotBeNull();
createdBook.ISBN10.ShouldBe("1515151515");
createdBook.Title.ShouldBe("The wind in the willows");
}
public BookQuery(BookQueryHandler queryHandler)
{
Field <BookType>(
"book",
arguments: new QueryArguments(
new QueryArgument <IdGraphType> {
Name = "id", Description = "The ID of the book."
}),
resolve: context =>
{
var id = context.GetArgument <int>("id");
var query = new GetBookByIdQuery {
Id = id
};
var book = queryHandler.Handle(query);
return(book);
});
Field <ListGraphType <BookType> >(
"books",
resolve: context =>
{
var query = new GetBooksQuery();
var books = queryHandler.Handle(query);
return(books);
});
}
public ICollection <BookInfo> Handle(GetBooksQuery query)
{
ICollection <BookInfo> books = new List <BookInfo>();
ICollection <BookInStore> availableBooks;
if (query.OnlyAvailable)
{
availableBooks = _storeRepository.GetAvailableBooks();
}
else
{
availableBooks = _storeRepository.GetAll();
}
foreach (var bookInStore in availableBooks)
{
var bookDetails = _bookRepository.Get(bookInStore.Id);
BookInfo bookInfo = Mapper.Map <BookInStore, BookInfo>(bookInStore);
Mapper.Map(bookDetails, bookInfo);
books.Add(bookInfo);
}
return(books);
}
public async Task <ActionResult <IEnumerable <BookResponse> > > GetAll([FromQuery] GetBooksQuery query)
{
_logger.Debug("GET api/v1/books");
var books = await _bookService.GetAllAsync(query.Category);
return(Ok(books.Select(b => new BookResponse(b, CreateLinks(b.Id))).ToArray()));
}
public async Task <IEnumerable <BookDto> > Handle(GetBooksQuery query, CancellationToken cancellationToken)
{
var list = await _context.Books.AsNoTracking()
.ProjectTo <BookDto>(_mapper.ConfigurationProvider)
.OrderBy(b => b.Title)
.ToListAsync(cancellationToken);
return(list);
}
public async Task <IActionResult> GetBooks(string search)
{
var query = new GetBooksQuery()
{
Search = search
};
return(Ok(await _mediator.Send(query, Request.HttpContext.RequestAborted)));
}
public IHttpActionResult GetLinksForAllBooks()
{
var query = new GetBooksQuery(onlyAvailable: false);
var result = _getBooksBaseInfoUseCase.Handle(query);
if (result != null)
{
return(Ok(result.SelectMany(book => book.Links).Where(link => link.Rel == "self")));
}
return(NotFound());
}
public IHttpActionResult Get()
{
var query = new GetBooksQuery(onlyAvailable: false);
var result = _getBooksBaseInfoUseCase.Handle(query);
if (result != null)
{
return(Ok(result.AsQueryable()));
}
return(NotFound());
}
public async Task <IEnumerable <Book> > Handle(GetBooksQuery query)
{
var books = await _libraryContext
.Set <Book>()
.Include(e => e.Author)
.Include(e => e.Category)
.Include(e => e.Country)
.Include(e => e.Language)
.Include(e => e.Publisher)
.ToListAsync();
return(books);
}
public async Task <IActionResult> GetBooks(int libraryId,
string query,
int pageNumber = 1,
int pageSize = 10,
[FromQuery] int?authorId = null,
[FromQuery] int?categoryId = null,
[FromQuery] int?seriesId = null,
[FromQuery] bool?favorite = null,
[FromQuery] bool?read = null,
[FromQuery] BookStatuses status = BookStatuses.Published,
[FromQuery] BookSortByType sortBy = BookSortByType.Title,
[FromQuery] SortDirection sortDirection = SortDirection.Ascending,
CancellationToken token = default(CancellationToken))
{
var filter = new BookFilter
{
AuthorId = authorId,
CategoryId = categoryId,
SeriesId = seriesId,
Favorite = favorite,
Read = read,
Status = status
};
var request = new GetBooksQuery(libraryId, pageNumber, pageSize, _userHelper.Account?.Id)
{
Query = query,
Filter = filter,
SortBy = sortBy,
SortDirection = sortDirection
};
var books = await _queryProcessor.ExecuteAsync(request, cancellationToken : token);
var args = new PageRendererArgs <BookModel, BookFilter>
{
Page = books,
RouteArguments = new PagedRouteArgs
{
PageNumber = pageNumber,
PageSize = pageSize,
Query = query,
SortBy = sortBy,
SortDirection = sortDirection
},
Filters = filter,
};
return(new OkObjectResult(_bookRenderer.Render(args, libraryId)));
}
public async Task <IList <BookDto> > Handle(
GetBooksQuery request,
CancellationToken cancellationToken)
{
var result = new List <BookDto>();
var booksInDatabase = await _repository.GetAllAsync();
foreach (var book in booksInDatabase)
{
var mappedBook = _mapper.Map <BookDto>(book);
result.Add(mappedBook);
}
return(result);
}
public async Task <SearchBooksResult> Handle(GetBooksQuery 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
full join dbo.Books as b on ba.BookId = b.Id
full join dbo.Authors as a on ba.AuthorId = a.Id
where b.Id in (Select Id from
(Select distinct Id, Rate
from dbo.Books
where Name like @SearchPattern or Summary like @SearchPattern
ORDER BY Rate DESC
OFFSET @SkipCount ROWS
FETCH NEXT @TakeCount ROWS ONLY ) as books)";
var books = new Dictionary <Guid, Book>();
var res = await connection.QueryAsync <Book, Author, Book>(
query,
(book, author) =>
{
if (!books.TryGetValue(book.Id, out var theBook))
{
theBook = book;
books.Add(book.Id, theBook);
}
if (author != null)
{
theBook.Authors.Add(author);
}
return(theBook);
},
new { SearchPattern = $"%{request.SearchPattern}%", SkipCount = request.SkipCount, TakeCount = request.TakeCount });
var totalBooksCount = await connection.ExecuteScalarAsync <int>(
@"Select Count(*)
from dbo.Books
where Name like @SearchPattern or Summary like @SearchPattern",
new { SearchPattern = $"%{request.SearchPattern}%" });
return(new SearchBooksResult(books.Values, totalBooksCount, books.Count));
}
}
public async Task ShouldReturnAllBooks()
{
await AddAsync(new Book
{
ISBN = "355118969-6",
Title = "Red Riding Hood",
Year = 1985,
Language = "English",
Edition = 5,
Binding = "hardcover",
Can_Lend = true,
Is_Interesting = false
});
await AddAsync(new Book
{
ISBN = "355118969-6",
Title = "Red Riding Hood",
Year = 1985,
Language = "English",
Edition = 6,
Binding = "hardcover",
Can_Lend = true,
Is_Interesting = false
});
await AddAsync(new Book
{
ISBN = "355118969-6",
Title = "Red Riding Hood",
Year = 1985,
Language = "English",
Edition = 7,
Binding = "hardcover",
Can_Lend = true,
Is_Interesting = false
});
var query = new GetBooksQuery();
var result = await SendAsync(query);
Assert.AreEqual(3, result.Count());
}
public void QueryDispatcher_TypeError__Test()
{
#region preparation
ApplicationContext _Context = new ApplicationContext();
QueryDispatcher _QueryDispatcher = new QueryDispatcher();
GetBooksQuery query = new GetBooksQuery(true); // init query
#endregion
#region test error
Assert.ThrowsException <InvalidOperationException>(
() => _QueryDispatcher.Dispatch <GetBooksQueryResult, WrongClass>(_Context, query)
); // call the dispatcher with the wrong class
#endregion
#region test success
_QueryDispatcher.Dispatch <GetBooksQueryResult, GetBooksQueryError>(_Context, query); // call the dispatcher with the right class
#endregion
}
public async Task <IEnumerable <BookDto> > Handle(GetBooksQuery request, CancellationToken cancellationToken)
{
var httpClient = _httpClientFactory.CreateClient("api");
var httpRequest = new HttpRequestMessage(
HttpMethod.Get,
"/books");
var response = await httpClient.SendAsync(
httpRequest, HttpCompletionOption.ResponseHeadersRead)
.ConfigureAwait(false);
response.EnsureSuccessStatusCode();
var content = await response.Content.ReadAsStringAsync();
var movieList = JsonConvert.DeserializeObject <IEnumerable <BookDto> >(content);
return(movieList);
}
public async Task <IActionResult> Get(
[FromQuery(Name = "pattern")] string search,
[FromQuery(Name = "skipCount")] int skipCount,
[FromQuery(Name = "takeCount")] int takeCount)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var query = new GetBooksQuery
{
SearchPattern = search ?? "",
SkipCount = skipCount,
TakeCount = takeCount
};
var result = await _mediator.Send(query);
return(Ok(result));
}
public Result <GetBooksQueryResult, GetBooksQueryError> GetBooks(GetBooksQuery query)
{
Result <GetBooksQueryResult, GetBooksQueryError> _queryResult;
try // try dispatch of the command
{
_queryResult =
_QueryDispatcher.Dispatch <GetBooksQueryResult, GetBooksQueryError>(_Context, query); //handle the request
}
catch (Exception _exception) // catch every exception
{
string errorMsg = $"Error in {this.GetType()} queryHandler. Message: {_exception.Message} \n Stacktrace: {_exception.StackTrace}";
_Log.ErrorFormat(errorMsg);
return(Result.Fail <GetBooksQueryResult, GetBooksQueryError>(GetBooksQueryError.Set_InternalServerError(errorMsg))); // return internal server error
}
finally
{
// do nothing
}
//GetBooksQueryHandler handler = new GetBooksQueryHandler();
//return handler.Handle(_Context, query);
return(_queryResult);
}
public async Task <IEnumerable <BookDto> > Handle(GetBooksQuery request, CancellationToken cancellationToken)
{
return(await _context.Book
.ProjectTo <BookDto>(_mapper.ConfigurationProvider)
.ToListAsync());
}
public async Task <IEnumerable <BooksDto> > Handle(GetBooksQuery request, CancellationToken cancellationToken) => _mapper.Map <IEnumerable <BooksDto> >(await _bookRepository.GetBooks(cancellationToken));
public async Task <IEnumerable <BookDto> > GetBooks([FromQuery] GetBooksQuery query)
{
return(await Mediator.Send(query));
}
public async Task <IEnumerable <GetBooksResponse> > Handle(GetBooksQuery request, CancellationToken cancellationToken)
{
var books = await _repository.ListAsync(null, cancellationToken);
return(books.Select(book => GetBooksResponse.FromBook(book)));
}
public Result <GetBooksQueryResult, GetBooksQueryError> GetBooks(GetBooksQuery query)
{
return(new GetBooksQueryHandler(_Context).Handle(query));
}
public async Task <Result <List <Book> > > Handle(GetBooksQuery request, CancellationToken cancellationToken)
{
var books = await this.repository.GetAsync();
return(Result.Ok(books.ToList()));
}
public async Task <ActionResult <IEnumerable <GetBooksResponse> > > GetBooks(
CancellationToken cancellationToken,
[FromQuery] GetBooksQuery query
) => Ok(await _mediator.Send(query, cancellationToken));
