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; }