public Task <Book> GetBookAsync(BookId id)
{
return(Context.Books.Include(s => s.Series)
//.ThenInclude(s => s.Series)
//.ThenInclude(b => b.Books)
.SingleAsync(b => b.Id == id));
}
public async ValueTask <BookContent?> FindBookContentAsync(BookId bookId)
{
var dao = await _dbContext.BookContent.FindAsync(bookId.Value)
.ConfigureAwait(false);
return(dao?.FromDao());
}
private static BookId CalculateBookId(Book book)
{
var bookId = new BookId()
{
SectionsStructure = new List <int>()
};
var queue = new Queue <Section>();
queue.Enqueue(book);
while (queue.Count > 0)
{
var section = queue.Dequeue();
var sectionSize = section.Problems?.Count ?? section.Sections.Count;
bookId.SectionsStructure.Add(sectionSize);
bookId.Hash = HashCode.Combine(bookId.Hash, sectionSize);
foreach (var innerSection in section.Sections ?? Enumerable.Empty <Section>())
{
queue.Enqueue(innerSection);
}
}
return(bookId);
}
public void ShouldThrow_WhenBookIdIsNull(
BookId bookId, Language language, BookDescription description)
{
Assert.Throws <ArgumentNullException>(() => new Book(null !, language, description));
Assert.Throws <ArgumentNullException>(() => new Book(bookId, null !, description));
Assert.Throws <ArgumentNullException>(() => new Book(bookId, language, null !));
}
public BookCreated(BookId bookId, string title, string description, AuthorId author)
{
BookId = bookId;
Title = title;
Description = description;
AuthorId = author;
}
public override int GetHashCode()
{
int hashBookId = BookId.GetHashCode();
int hashUserId = UserId.GetHashCode();
return(hashBookId ^ hashUserId);
}
public LendBook(
BookId bookId,
UserId userId)
{
BookId = bookId;
UserId = userId;
}
public BookLent(BookId id, string borrower, DateTime date, TimeSpan expectedDuration)
{
Id = id;
Borrower = borrower;
Date = date;
ExpectedDuration = expectedDuration;
}
public BookId GetBookIdByNameAndAuthor(string name, string author)
{
if (name == "" || author == "")
{
throw new Exception("No information about name or book author");
}
else
{
string booksQuery = String.Format("SELECT TOP 1 [Id] FROM [dbo].[tblBook] WHERE [Name] = '{0}' AND [Author] = '{1}' AND [StatusId] = 1", name, author);
BookId book = new BookId();
using (SqlConnection connection = new SqlConnection(_connectionString))
{
connection.Open();
using (SqlCommand command = new SqlCommand())
{
command.Connection = connection;
command.CommandType = CommandType.Text;
command.CommandText = booksQuery;
using (SqlDataReader reader = command.ExecuteReader())
{
while (reader.Read())
{
book.Id = (int)reader["Id"];
}
}
}
return(book);
}
}
}
public override void Validate()
{
if (!BookId.isGraterThanZero())
{
AddNotification(nameof(BookId), "Book identification is invalid");
}
}
public ReturnBook(
BookId bookId,
UserId userId)
{
BookId = bookId;
UserId = userId;
}
public ValueTask RemoveAllForBook(BookId bookId)
{
foreach (var sentence in _sentences.Where(sentence => sentence.Value.BookId == bookId).ToList())
{
_sentences.Remove(sentence.Key);
}
return(default);
private Book(BookId id, string bookName, string authorName, DateTime createdOn, DateTime updatedOn)
{
Id = id;
BookName = bookName;
AuthorName = authorName;
CreatedOn = createdOn;
UpdatedOn = updatedOn;
}
public BookReturned(BookId id, string @by, TimeSpan after,
bool late)
{
Id = id;
By = by;
After = after;
Late = late;
}
public AddBook(
BookId bookId,
BookName bookName,
YearOfPrint yearOfPrint) : base(bookId)
{
BookName = bookName;
YearOfPrint = yearOfPrint;
}
public override int GetHashCode()
{
int hashCode = -437730420;
hashCode = hashCode * -1521134295 + BookId.GetHashCode();
hashCode = hashCode * -1521134295 + ChapterId.GetHashCode();
return(hashCode);
}
public async Task ShouldThrow_WhenBookContentNotFound(BookId bookId)
{
_bookRepository.Setup(x => x.FindBookContentAsync(bookId))
.ReturnsAsync((BookContent?)null);
await AssertThrowsAsync <InvalidOperationException>(
async() => await _sut.ImportBookAsync(bookId));
}
public async Task <IActionResult> PostBook([FromBody] PostBookHttpRequest?postBookHttpRequest)
{
CreateBookCommand createBookCommand = new CreateBookCommand(postBookHttpRequest?.BookName ?? string.Empty,
postBookHttpRequest?.AuthorName ?? string.Empty);
BookId bookId = await _executionContext.ExecuteAsync(createBookCommand, CancellationToken.None);
return(StatusCode((int)HttpStatusCode.Created, bookId.Value));
}
public Sentence CreateSentence(BookId bookId, string validatedSentence, int indexInBook)
{
validatedSentence = string.Join(" ", _textProcessor.GetWordsEnumerable(validatedSentence));
var sentenceType = SentenceType.Normal;
var sentenceId = SentenceId.New();
var words = _textProcessor.GetWordsEnumerable(validatedSentence).ToArray();
var wordsList = new List <Word>(words.Length);
var wordsInSentence = words
.GroupBy(word => word)
.Select(group => new
{
Word = group.Key,
Count = group.Count()
}).ToDictionary(x => x.Word);
foreach (var word in words)
{
if (word.All(character => TextConstants.PunctuationCharacters.Contains(character)) &&
word.Length > 1)
{
sentenceType = SentenceType.Other;
}
if (word.EndsWith(".?", StringComparison.Ordinal) || word.EndsWith(".!", StringComparison.Ordinal))
{
sentenceType = SentenceType.Other;
}
}
var rawWordsInSentence = words
.Select(word => _textProcessor.NormalizeWord(word))
.GroupBy(word => word)
.Select(group => new
{
Word = group.Key,
Count = group.Count()
}).ToDictionary(x => x.Word);
var index = 0;
foreach (var word in words)
{
var keyPairs = CreateKeyPairs(validatedSentence, word);
var rawWord = _textProcessor.NormalizeWord(word);
wordsList.Add(new Word(
sentenceId, index,
word, rawWord,
wordsInSentence[word].Count, rawWord == string.Empty ? 0 : rawWordsInSentence[rawWord].Count,
keyPairs));
index++;
}
return(new Sentence(bookId, sentenceId, sentenceType, indexInBook, validatedSentence, wordsList));
}
public virtual void Validate(ValidationResult result)
{
BookId.ValidateRequired(result, nameof(BookId));
foreach (var page in Pages)
{
page.Validate(result);
}
}
public bool Equals(Book other)
{
if (ReferenceEquals(null, other))
{
return(false);
}
return(BookId.Equals(other.BookId));
}
public void BookId_ShouldBeBetween1And50Characters()
{
Assert.Throws <ArgumentNullException>(() => new BookId(null !));
Assert.Throws <ArgumentException>(() => new BookId(string.Empty));
Assert.Throws <ArgumentException>(() => new BookId(new string('a', 51)));
_ = new BookId(new string('a', 50));
_ = new BookId("a");
}
private async Task CheckBookAvailibility(BookId bookId, string bookName, int amount)
{
var book = await bookRepository.GetByIdAsync(bookId);
if (book.Amount.Amount < amount)
{
throw new ArgumentException($"Book with title {bookName} is not in stock");
}
}
public void ShouldCreate(
BookId bookId, Language language, BookDescription description)
{
var sut = new Book(bookId, language, description);
var state = sut.GetState();
Assert.Equal(bookId, state.BookId);
Assert.Equal(language, state.Language);
Assert.Equal(description, state.Description);
}
public async Task ShouldNotRemoveSentences_WhenArchivingFails(
BookId bookId)
{
_bookRepository.Setup(x => x.FindBookAsync(bookId))
.ThrowsAsync(NewTestException());
await AssertThrowsAsync <TestException>(
() => _sut.ArchiveBookAsync(bookId));
_sentenceRepository.Verify(x => x.RemoveAllForBook(bookId), Times.Never);
}
public async Task ShouldThrow_AndNotUpdateAnything_WhenBookDoesNotExist(
BookId bookId)
{
_bookRepository.Setup(x => x.FindBookAsync(bookId))
.ReturnsAsync((Book?)null);
await AssertThrowsAsync <InvalidOperationException>(
() => _sut.ArchiveBookAsync(bookId));
_sentenceRepository.Verify(x => x.RemoveAllForBook(It.IsAny <BookId>()), Times.Never);
_bookRepository.Verify(x => x.UpdateBookAsync(It.IsAny <Book>()), Times.Never);
}
public override int GetHashCode()
{
unchecked
{
int result = (BookId != null ? BookId.GetHashCode() : 0);
result = (result * 397) ^ (Title != null ? Title.GetHashCode() : 0);
result = (result * 397) ^ (Author != null ? Author.GetHashCode() : 0);
result = (result * 397) ^ (Publication != null ? Publication.GetHashCode() : 0);
result = (result * 397) ^ (Date != null ? Date.GetHashCode() : 0);
return(result);
}
}
public async Task ShouldNotUpdateAnything_WhenBookIsAlreadyArchived(
BookId bookId)
{
var book = Fixture.CreateBook(config => config.With(x => x.IsArchived, true));
_bookRepository.Setup(x => x.FindBookAsync(bookId))
.ReturnsAsync(book);
await AssertThrowsAsync <InvalidOperationException>(
() => _sut.ArchiveBookAsync(bookId));
_sentenceRepository.Verify(x => x.RemoveAllForBook(It.IsAny <BookId>()), Times.Never);
_bookRepository.Verify(x => x.UpdateBookAsync(It.IsAny <Book>()), Times.Never);
}
//internal static Task UpdateBook(Book sut)
//{
// var connectionString = ConnectivityService.GetConnectionString("TEMP");
// var context = new BookOrganizer2DbContext(connectionString);
// var repository = new BookRepository(context);
// var bookService = new BookService(repository);
// var command = new Commands.Update
// {
// Id = sut.Id,
// Title
// Notes = sut.Notes
// };
// return bookService.Handle(command);
//}
public static Task CreateInvalidBook()
{
var connectionString = ConnectivityService.GetConnectionString("TEMP");
var context = new BookOrganizer2DbContext(connectionString);
var repository = new BookRepository(context);
var bookService = new BookService(repository);
var bookId = new BookId(SequentialGuid.NewSequentialGuid());
var command = new Commands.Create {
Id = bookId
};
return(bookService.Handle(command));
}
// DELETE
public static Task RemoveBook(BookId id)
{
var connectionString = ConnectivityService.GetConnectionString("TEMP");
var context = new BookOrganizer2DbContext(connectionString);
var repository = new BookRepository(context);
var bookService = new BookService(repository);
var command = new Commands.Delete
{
Id = id,
};
return(bookService.Handle(command));
}
public async ValueTask <BookImportResult> ImportBookAsync(BookId bookId)
{
var book = await _bookStore.FindBookAsync(bookId)
.ConfigureAwait(false);
if (book == null)
{
throw new InvalidOperationException($"Book {bookId} is not found.");
}
var bookContent = await _bookStore.FindBookContentAsync(bookId)
.ConfigureAwait(false);
if (bookContent == null)
{
throw new InvalidOperationException($"Content for the book {bookId} is not found.");
}
book.StartProcessing();
await _bookStore.UpdateBookAsync(book)
.ConfigureAwait(false);
await _sentenceRepository.RemoveAllForBook(bookId)
.ConfigureAwait(false);
// TODO: Everything below is not unit tested yet.
try
{
var result = await ImportBookAsync(book, bookContent)
.ConfigureAwait(false);
book.FinishProcessing();
await _bookStore.UpdateBookAsync(book)
.ConfigureAwait(false);
return(result);
}
catch (Exception exception)
{
_logger.LogError(exception, "Error while importing the book {BookId}.", bookId.Value);
book.ErrorProcessing();
await _bookStore.UpdateBookAsync(book)
.ConfigureAwait(false);
throw new InvalidOperationException($"Error while importing book {bookId}");
}
}
public static Task UpdateReadDates(BookId bookId, List <BookReadDate> readDates)
{
var connectionString = ConnectivityService.GetConnectionString("TEMP");
var context = new BookOrganizer2DbContext(connectionString);
var repository = new BookRepository(context);
var bookService = new BookService(repository);
var command = new Commands.SetBookReadDates
{
Id = bookId,
BookReadDates = readDates
};
return(bookService.Handle(command));
}
public void AddBookState(BookId id, string title)
{
var state = new BookState {Id = id, Title = title};
states.Add(id, state);
}
public BookState GetBookState(BookId id)
{
return states[id];
}
public void SetLent(BookId id, bool lent)
{
states[id].Lent = lent;
}
public BookRegistered(BookId id, string title, string isbn)
{
Id = id;
Title = title;
Isbn = isbn;
}
