private List <PocoBook> FetchBooksInfoFromResponse(Rootobject root)
{
if (root == null || root.items == null)
{
return(new List <PocoBook>());
}
List <PocoBook> retval = new List <PocoBook>();
for (int i = 0; i < root.items.Length; i++)
{
Collection <string> authors = new Collection <string>();
Array.ForEach(root.items[i].volumeInfo.authors ?? Array.Empty <string>(), str => authors.Add(str));
PocoBook abook = new PocoBook(root.File.FullName, root.items[i].volumeInfo.title,
authors, string.Empty, string.Empty)
{
Description = root.items[i].volumeInfo.description,
Language = root.items[i].volumeInfo.language,
Publisher = root.items[i].volumeInfo.publisher,
ImageLink = root.items[i].volumeInfo.imageLinks?.smallThumbnail,
PublishedDate = root.items[i].volumeInfo.publishedDate.ToDateTime(),
Isbn = root.items[i].ToIsbn() ?? root.File.UniqueIdentifier(),
Authors = authors
};
Array.ForEach(root.items[i].volumeInfo.categories ?? Array.Empty <string>(), str => abook.Categories.Add(str));
retval.Add(abook);
}
return(retval);
}
public void OnNewQueryFilter(string message)
{
BooksCollectedDataMapper mapper = new BooksCollectedDataMapper(ConfData.RepositoryHost, ConfData.DatabaseName);
if (string.IsNullOrEmpty(message))
{
foreach (var book in mapper.Read())
{
if (!Books.Contains(book))
{
Books.Add(book);
}
}
return;
}
PocoBook titlebook = new PocoBook("");
titlebook.Title = message;
var filtered = mapper.Read(titlebook);
if (filtered.Any())
{
Books.Clear();
}
foreach (var book in filtered)
{
Books.Add(book);
}
}
public static BookAtHome AnalyzeResults(PocoBook minimalbookinfo, List <PocoBook> booksFromProvider, IBookParserTrace trace)
{
trace?.TraceInfo("AnalyzeResults start");
if (booksFromProvider == null || booksFromProvider.Count == 0)
{
if (!String.IsNullOrEmpty(minimalbookinfo?.Title) && minimalbookinfo.Authors.Count != 0)
{
minimalbookinfo.BookReliability = PocoBook.Reliability.Medium;
return(minimalbookinfo);
}
throw new ArgumentNullException(nameof(booksFromProvider));
}
if (booksFromProvider.Count == 1)
{
booksFromProvider.First().BookReliability = PocoBook.Reliability.High;
return(booksFromProvider.First());
}
if (!string.IsNullOrEmpty(minimalbookinfo.SearchPhrase))
{
booksFromProvider.First().BookReliability = PocoBook.Reliability.Medium;
return(booksFromProvider.First());
}
return(FindTheBookInfoFromCollection(minimalbookinfo.File, booksFromProvider, minimalbookinfo.SearchTitle, trace));
}
public void TestReadBookByLanguage_NotExisting_ReturnNoBooks()
{
PocoBook book = new PocoBook();
book.Language = "rr";
var result = mybooks.Read(book);
Assert.AreEqual(0, result.Count);
}
public void TestReadBookByLanguage_Correctlanguage_ReturnManyBooks()
{
PocoBook book = new PocoBook();
book.Language = "it";
var result = mybooks.Read(book);
Assert.AreEqual(9, result.Count);
}
public void TestReadBookByTitle_NotExisting_ReturnEmpty()
{
PocoBook queryBook = new PocoBook();
queryBook.Title = "asdasd";
var result = mybooks.Read(queryBook);
Assert.IsEmpty(result);
}
public override BookAtHome GetPocoBook(string filepath)
{
iText.Kernel.Pdf.PdfReader reader = null;
iText.Kernel.Pdf.PdfDocument pDoc = null;
const int extracted_phrase_len = 500;
try
{
if (File.Exists(filepath))
{
reader = new iText.Kernel.Pdf.PdfReader(filepath);
pDoc = new iText.Kernel.Pdf.PdfDocument(reader);
int nPages = pDoc.GetNumberOfPages();
int maxsearch = nPages < 15 ? nPages : 10;
string currentText = string.Empty;
for (int i = 1; i <= maxsearch; i++)
{
ITextExtractionStrategy strategy = new SimpleTextExtractionStrategy();
currentText = PdfTextExtractor.GetTextFromPage(pDoc.GetPage(i), strategy);
currentText = Encoding.UTF8.GetString(ASCIIEncoding.Convert(Encoding.Default, Encoding.UTF8, Encoding.Default.GetBytes(currentText)));
if (currentText.ToLower().Contains("isbn", System.StringComparison.InvariantCulture))
{
string pattern = @"ISBN(-1(?:(0)|3))?:?\x20(\s)*[0-9]+[- ][0-9]+[- ][0-9]+[- ][0-9]*[- ]*[xX0-9]";
Match m = Regex.Match(currentText.Replace(":", "").Replace("-", " "), pattern);
if (m.Success)
{
PocoBook retBook = base.GetPocoBook(filepath) as PocoBook;
retBook.Isbnsearch = m.Value;
return(retBook);
}
}
}
PocoBook abook = base.GetPocoBook(filepath) as PocoBook;
int len = currentText.Length < extracted_phrase_len ? currentText.Length : extracted_phrase_len;
abook.SearchPhrase = currentText.Substring(0, len);
return(abook);
}
}
catch (IOException)
{
return(new PocoBook(filepath));
}
finally
{
((IDisposable)reader)?.Dispose();
((IDisposable)pDoc)?.Dispose();
reader?.Close();
}
return(base.GetPocoBook(filepath));
}
private void ListView_MouseDoubleClick(object sender, System.Windows.Input.MouseButtonEventArgs e)
{
BookDetailsWindow details = new BookDetailsWindow();
details.Show();
PocoBook selectedBook = (sender as ListView).SelectedItem as PocoBook;
MSG.Messenger.Default.Send(selectedBook);
}
public void TestInsert_IsbnEmpty_ExpectedMongoWriteException()
{
PocoBook book = new PocoBook("blabla");
book.File = @"c:\test\prova.cc";
book.Title = "mio titolo";
book.Isbn = string.Empty;
Assert.Throws <ArgumentNullException>(delegate { mybooks.Write(book); });
}
public void TestInsert_DuplicatedBook_ExpectedMongoWriteException()
{
PocoBook book = new PocoBook("blabla");
book.File = @"c:\test\prova.cc";
book.Title = "mio titolo";
book.Isbn = "PSU:000054186286";
Assert.Throws <MongodbDataMapperException <PocoBook> >(delegate { mybooks.Write(book); });
}
public void TestInsert_HappyPath()
{
PocoBook book = new PocoBook("blabla");
book.File = @"c:\test\prova.cc";
book.Title = "mio titolo";
book.Isbn = System.Guid.NewGuid().ToString();
book.BookReliability = PocoBook.Reliability.High;
mybooks.Write(book);
}
public void TestReadBookByTitle_CorrectTitle_ReturnOneBook()
{
PocoBook book = new PocoBook();
book.Title = "Oltre";
var result = mybooks.Read(book);
Assert.AreEqual(1, result.Count);
Assert.AreEqual("Oltre il nulla", result[0].Title);
Assert.AreEqual("9788831132763", result[0].Isbn);
}
public void TestReadBookbyCategory_GetComputers_ReturnBooks()
{
var query = new PocoBook();
query.Categories = new Collection <string> {
"Computers"
};
var books = mybooks.Read(query);
Assert.IsNotNull(books);
Assert.AreEqual(7, books.Count);
}
private void GetBookDetailedInformation(PocoBook obj)
{
Title = obj.Title;
Description = obj.Description;
Publisher = obj.Publisher;
Language = obj.Language;
PublisherDate = obj.PublishedDate.Year.ToString();
Isbn = obj.Isbn;
PageCount = obj.PageCount.ToString();
Authors = string.Join(", ", obj.Authors);
Publisher = string.Join(", ", obj.Publisher);
ImageLink = obj.ImageLink;
_file = obj.File;
}
public List <PocoBook> FetchBookInfo(PocoBook book)
{
if (PocoBook.IsNullOrEmpty(book))
{
throw new ArgumentNullException(nameof(book), "Book cannot be null.");
}
Uri myquery = CreateQueryOnBook(book);
Rootobject root = ExecuteGoogleRequest(myquery);
root.File = new FileInfo(book.File);
return(FetchBooksInfoFromResponse(root));
}
public void TestReadBookbyReliability_GetLow_ReturnBooks()
{
var query = new PocoBook();
query.BookReliability = PocoBook.Reliability.Low;
var books = mybooks.Read(query);
var res = (from book in books
where book.BookReliability == PocoBook.Reliability.Low
select book.Isbn).ToList <string>();
Assert.IsNotNull(books);
Assert.AreEqual(2, books.Count);
Assert.Contains("9780470512579", res);
Assert.Contains("9788831132763", res);
}
public void TestUpdateTitle_ExistingBook_ReturnTitleUpdated()
{
string isbn = "9780321246424";
PocoBook query = new PocoBook();
query.Isbn = isbn;
var toUpdate = mybooks.Read(query).First();
string newTitle = "Cross-platform Development in Cpp";
toUpdate.Title = newTitle;
var updatedBook = mybooks.Update(toUpdate);
Assert.AreEqual(isbn, updatedBook.Isbn);
Assert.AreEqual(newTitle, updatedBook.Title);
}
public void TestUpdateBook_RemoveAuthor_ReturnBookUpdated()
{
string isbn = "PSU:000054186286";
var query = new PocoBook();
query.Isbn = isbn;
var book = mybooks.Read(query).First();
string[] newAuthors = { "Frank Buschmann", "Douglas C. Schmidt", "Regine Meunier", "Hans Rohnert", "Michael Stal" };
book.Authors.Remove("Peter Sommerlad");
var updatedBook = mybooks.Update(book);
Assert.AreEqual(isbn, updatedBook.Isbn);
Assert.AreEqual(5, updatedBook.Authors.Count);
Assert.AreEqual(newAuthors, updatedBook.Authors);
}
public void TestReadBookbyFormat_GetPdf_ReturnBooks()
{
string format = "pdf";
var query = new PocoBook();
query.Format = format;
var books = mybooks.Read(query);
var res = (from book in books
where book.Format == format
select book.Isbn).ToList <string>();
Assert.IsNotNull(books);
Assert.AreEqual(12, books.Count);
Assert.Contains("UCSD:31822028759850", res);
Assert.Contains("OCLC:1113772535", res);
Assert.Contains("8852010440", res);
}
public void TestReadBookByTitle_CorrectTitle_ReturnMultipleBooks()
{
PocoBook queryBook = new PocoBook();
queryBook.Title = "Pattern-Oriented Software Architecture";
var result = mybooks.Read(queryBook);
Assert.AreEqual(3, result.Count);
var firstbook = result.First(p => p.Isbn == "PSU:000054186286");
var secondBook = result.First(p => p.Isbn == "UCSD:31822028759850");
var thirdBook = result.First(p => p.Isbn == "9780470512579");
Assert.IsNotNull(firstbook);
Assert.AreEqual("Pattern-Oriented Software Architecture, A System of Patterns", firstbook.Title);
Assert.IsNotNull(secondBook);
Assert.AreEqual("Pattern-Oriented Software Architecture, Patterns for Concurrent and Networked Objects", secondBook.Title);
Assert.IsNotNull(thirdBook);
Assert.AreEqual("Pattern-Oriented Software Architecture, On Patterns and Pattern Languages", thirdBook.Title);
}
public void TestUpdateBook_AddCategory_ReturnBookUpdated()
{
string isbn = "PSU:000054186286";
var query = new PocoBook();
query.Isbn = isbn;
var book = mybooks.Read(query).First();
Collection <string> category = new Collection <string>()
{
"Computers", "Science"
};
book.Categories.Add("Science");
var updatedBook = mybooks.Update(book);
Assert.AreEqual(isbn, updatedBook.Isbn);
Assert.AreEqual(2, updatedBook.Categories.Count);
Assert.AreEqual(category, updatedBook.Categories);
}
public void TestUpdateTitle_AddAuthor_ReturnBookUpdated()
{
string isbn = "PSU:000054186286";
var query = new PocoBook();
query.Isbn = isbn;
var book = mybooks.Read(query).First();
book.Authors.Add("Peppino");
Collection <string> expAuthors = book.Authors;
var updatedBook = mybooks.Update(book);
Assert.AreEqual(isbn, updatedBook.Isbn);
Assert.AreEqual(expAuthors.Count, updatedBook.Authors.Count);
Assert.AreEqual(expAuthors, updatedBook.Authors);
//Clean
book.Authors.Remove("Peppino");
mybooks.Update(book);
}
public void TestReadBookByAuthor_CorrectAuthor_ReturnBooks()
{
PocoBook book = new PocoBook();
book.Authors = new Collection <string> {
"Asimov"
};
var result = mybooks.Read(book);
Assert.AreEqual(3, result.Count);
var firstbook = result.First(p => p.Title == "Preludio alla fondazione");
var secondBook = result.First(p => p.Title == "Fondazione e terra");
var thirdBook = result.First(p => p.Title == "Cavalieri cosmici");
Assert.IsNotNull(firstbook);
Assert.AreEqual("9788804401841", firstbook.Isbn);
Assert.IsNotNull(secondBook);
Assert.AreEqual("9788804403029", secondBook.Isbn);
Assert.IsNotNull(thirdBook);
Assert.AreEqual("9788834700563", thirdBook.Isbn);
}
public void TestRemoveBook_CorrectlyRemoved()
{
PocoBook myNewBook = new PocoBook();
var myguid = Guid.NewGuid();
string title = "asdfasdfa";
myNewBook.Isbn = myguid.ToString();
myNewBook.Title = title;
mybooks.Write(myNewBook);
var test = mybooks.Read(myNewBook).First();
Assert.AreEqual(myguid.ToString(), test.Isbn);
Assert.AreEqual("asdfasdfa", test.Title);
mybooks.Delete(myNewBook);
var test2 = mybooks.Read(myNewBook);
Assert.IsEmpty(test2);
}
private Uri CreateQueryOnBook(PocoBook book)
{
if (PocoBook.IsNullOrEmpty(book))
{
throw new ArgumentNullException(nameof(book), "Book cannot be null or empty");
}
string endpoint = "https://www.googleapis.com/books/v1/volumes?q=###&maxResults=40&country=IT";
string query;
if (!string.IsNullOrEmpty(book.Isbnsearch))
{
query = "isbn:" + book.Isbnsearch.Replace("-", "").Replace("ISBN", "", true, null).Replace(" ", "");
endpoint = endpoint.Replace("###", query);
return(new Uri(endpoint));
}
if (!string.IsNullOrEmpty(book.SearchPhrase))
{
query = string.Format(" \"{0}\" ", book.SearchPhrase);
endpoint = endpoint.Replace("###", query);
return(new Uri(endpoint));
}
if (book.Authors == null || book.Authors.Count == 0)
{
query = string.Format("intitle:{0}", book.SearchTitle);
endpoint = endpoint.Replace("###", query);
return(new Uri(endpoint));
}
query = string.Format("intitle:{0}&inauthor:{1}", book.SearchTitle, string.Join(", ", book.Authors));
endpoint = endpoint.Replace("###", query);
return(new Uri(endpoint));
}
public void TestReadBookByIsbn_CorrectIsbnAndVerifyFullFields_FullBookCorrect()
{
string expTitle = "Pattern-Oriented Software Architecture, On Patterns and Pattern Languages";
string expPublisher = "John Wiley & Sons";
DateTime expPubDate = new DateTime(2007, 4, 29);
int expPageCount = 0;
string expDescr = "Software patterns have revolutionized the way developers think about how software is designed, built, and documented, and this unique book offers an in-depth look of what patterns are, what they are not, and how to use them successfully The only book to attempt to develop a comprehensive language that integrates patterns from key literature, it also serves as a reference manual for all pattern-oriented software architecture (POSA) patterns Addresses the question of what a pattern language is and compares various pattern paradigms Developers and programmers operating in an object-oriented environment will find this book to be an invaluable resource";
string expLang = "en";
PocoBook.Reliability expBookRel = PocoBook.Reliability.Low;
string expFormat = "pdf";
const string isbn = "9780470512579";
PocoBook querybook = new PocoBook();
querybook.Isbn = isbn;
var result = mybooks.Read(querybook).First();
string[] expAuthors = { "Frank Buschmann", "Kevin Henney", "Douglas C. Schmidt" };
string[] expCategories = { "Computers" };
Assert.IsNotNull(result);
Assert.AreEqual(expTitle, result.Title);
Assert.AreEqual(expPublisher, result.Publisher);
Assert.AreEqual(expPubDate, result.PublishedDate);
Assert.AreEqual(expPageCount, result.PageCount);
Assert.AreEqual(expDescr, result.Description);
Assert.AreEqual(expFormat, result.Format);
Assert.AreEqual(expBookRel, result.BookReliability);
Assert.AreEqual(expLang, result.Language);
Assert.AreEqual(expAuthors, result.Authors);
Assert.AreEqual(expCategories, result.Categories);
}
public void Add(PocoBook item)
{
Items.Add(item);
}
public void TestReadBook_BookEmpty_ReturnNull()
{
PocoBook mybook = new PocoBook();
Assert.Throws <ArgumentNullException>(() => mybooks.Read(mybook));
}
