/// <summary>
/// Sorts books by one of available tags
/// </summary>
/// <param name="tagName">Tag name</param>
public void SortBooksByTag(BookTags tagName)
{
switch (tagName)
{
case BookTags.Isbn:
this.AllBooks = this.AllBooks.OrderBy(orderTag => orderTag.Isbn).ToList();
break;
case BookTags.Name:
this.AllBooks = this.AllBooks.OrderBy(orderTag => orderTag.Name).ToList();
break;
case BookTags.Author:
this.AllBooks = this.AllBooks.OrderBy(orderTag => orderTag.Author).ToList();
break;
case BookTags.Edition:
this.AllBooks = this.AllBooks.OrderBy(orderTag => orderTag.Edition).ToList();
break;
case BookTags.EditionYear:
this.AllBooks = this.AllBooks.OrderBy(orderTag => orderTag.EditionYear).ToList();
break;
case BookTags.Pages:
this.AllBooks = this.AllBooks.OrderBy(orderTag => orderTag.Pages).ToList();
break;
case BookTags.Price:
this.AllBooks = this.AllBooks.OrderBy(orderTag => orderTag.Price).ToList();
break;
}
}
/// <summary>
/// Sorts books by one of available tags
/// </summary>
public void SortBooksByTag(BookTags tagName)
{
switch (tagName)
{
case BookTags.isbn:
AllBooks = AllBooks.OrderBy(orderTag => orderTag.Isbn).ToList();
break;
case BookTags.name:
AllBooks = AllBooks.OrderBy(orderTag => orderTag.Name).ToList();
break;
case BookTags.author:
AllBooks = AllBooks.OrderBy(orderTag => orderTag.Author).ToList();
break;
case BookTags.edition:
AllBooks = AllBooks.OrderBy(orderTag => orderTag.Edition).ToList();
break;
case BookTags.editionYear:
AllBooks = AllBooks.OrderBy(orderTag => orderTag.EditionYear).ToList();
break;
case BookTags.pages:
AllBooks = AllBooks.OrderBy(orderTag => orderTag.Pages).ToList();
break;
case BookTags.price:
AllBooks = AllBooks.OrderBy(orderTag => orderTag.Price).ToList();
break;
}
}
public async Task <IActionResult> CreateBookTag(int bookId, int tagId) // ova ke bide za sekoj nov tag koga ke sakam da go stavam
{
var bookTag = new BookTags()
{
TagId = tagId,
BookId = bookId
};
_repo.Add(bookTag);
await _repo.SaveAll();
return(Ok("Tag,Saved"));
}
/// <summary>
/// Sorts book by tag.
/// </summary>
/// <param name="tag">Tag</param>
public void SortBooksByTag(BookTags tag)
{
List <Book> sortedBooks = new List <Book>();
logger.Trace($"Sorting book by tag {tag}");
switch (tag)
{
case BookTags.Id:
sortedBooks = bookListStorage.Books.OrderBy(b => b.Id).ToList();
break;
case BookTags.ISBN:
sortedBooks = bookListStorage.Books.OrderBy(b => b.ISBN).ToList();
break;
case BookTags.Author:
sortedBooks = bookListStorage.Books.OrderBy(b => b.Author).ToList();
break;
case BookTags.Title:
sortedBooks = bookListStorage.Books.OrderBy(b => b.Title).ToList();
break;
case BookTags.Publisher:
sortedBooks = bookListStorage.Books.OrderBy(b => b.Publisher).ToList();
break;
case BookTags.YearPublished:
sortedBooks = bookListStorage.Books.OrderBy(b => b.YearPublished).ToList();
break;
case BookTags.Pages:
sortedBooks = bookListStorage.Books.OrderBy(b => b.Pages).ToList();
break;
case BookTags.Price:
sortedBooks = bookListStorage.Books.OrderBy(b => b.Price).ToList();
break;
default:
break;
}
bookListStorage.Books = sortedBooks;
logger.Debug("Writing changes to storage");
bookListStorage.Synchronize();
}
public void BookStringRepresentationTest1()
{
Book book = new Book(19573924, "Author", "Name", 2, 2019, 100, 55.5);
BookTags[] bookTags = new BookTags[]
{
BookTags.Name,
BookTags.Price,
BookTags.Edition
};
string expected = "Name: Name\nPrice: 55,5$\nEdition: 2\n";
string actual = book.GetStringRepresentation(bookTags);
Assert.AreEqual(expected, actual);
}
/// <summary>
/// Sorts book by tag.
/// </summary>
/// <param name="tag">Tag</param>
public void SortBooksByTag(BookTags tag)
{
List <Book> sortedBooks = new List <Book>();
switch (tag)
{
case BookTags.Id:
sortedBooks = bookListStorage.Books.OrderBy(b => b.Id).ToList();
break;
case BookTags.ISBN:
sortedBooks = bookListStorage.Books.OrderBy(b => b.ISBN).ToList();
break;
case BookTags.Author:
sortedBooks = bookListStorage.Books.OrderBy(b => b.Author).ToList();
break;
case BookTags.Title:
sortedBooks = bookListStorage.Books.OrderBy(b => b.Title).ToList();
break;
case BookTags.Publisher:
sortedBooks = bookListStorage.Books.OrderBy(b => b.Publisher).ToList();
break;
case BookTags.YearPublished:
sortedBooks = bookListStorage.Books.OrderBy(b => b.YearPublished).ToList();
break;
case BookTags.Pages:
sortedBooks = bookListStorage.Books.OrderBy(b => b.Pages).ToList();
break;
case BookTags.Price:
sortedBooks = bookListStorage.Books.OrderBy(b => b.Price).ToList();
break;
default:
break;
}
bookListStorage.Books = sortedBooks;
bookListStorage.Synchronize();
}
public async Task <IActionResult> CreateBook(ViewBookModel viewBook)
{
using (var ms = new MemoryStream())
{
viewBook.BookFile.CopyTo(ms);
var fileBytes = ms.ToArray();
viewBook.ByteBook = fileBytes;
}
var book = new Book()
{
Author = viewBook.Author,
Title = viewBook.Title,
ByteBook = viewBook.ByteBook
};
var repoTag = await _repo.GetTag(3);
//var newTag = new Tag() { TagName = "NovTag" };
var bookTag = new BookTags()
{
TagId = repoTag.Id,
BookId = book.Id
};
_repo.Add(bookTag);
_repo.Add(book);
if (await _repo.SaveAll())
{
var url = "https://localhost:44307/api/books/";
return(Redirect(url + book.Id));
}
return(Ok("Was not saved"));
}
private void UpdateBookTags()
{
BookTags.Clear();
Dictionary <string, BookTag> bookTagSet = new Dictionary <string, BookTag>();
foreach (BookRead book in BooksRead)
{
if (book.Tags == null || book.Tags.Count == 0)
{
continue;
}
foreach (string tag in book.Tags)
{
string trimmedTag = tag.Trim();
if (bookTagSet.ContainsKey(trimmedTag))
{
bookTagSet[trimmedTag].BooksWithTag.Add(book);
}
else
{
BookTag bookTag = new BookTag {
Tag = trimmedTag
};
bookTag.BooksWithTag.Add(book);
bookTagSet.Add(trimmedTag, bookTag);
}
}
}
foreach (BookTag bookTag in bookTagSet.Values.ToList())
{
BookTags.Add(bookTag);
}
}
public async Task <IActionResult> Create(ViewBookModel viewBook)
{
var TagsForNewBoook = await _repo.TagsForNewBook();
using (var ms = new MemoryStream())
{
viewBook.BookFile.CopyTo(ms);
var fileBytes = ms.ToArray();
viewBook.ByteBook = fileBytes;
}
var newBook = new Book()
{
Id = GetHashCode(),
Author = viewBook.Author,
Title = viewBook.Title,
ByteBook = viewBook.ByteBook,
IsNew = viewBook.IsNew
};
foreach (var tag in TagsForNewBoook)
{
tag.ForNewBook = false;
var bookTag = new BookTags()
{
BookId = newBook.Id,
TagId = tag.Id
};
_repo.Add(bookTag);
}
_repo.Add(newBook);
//_repo.SaveAll();
//var url = "https://localhost:44307/api/books/";
//return Redirect(url + newBook.Id);
if (await _repo.SaveAll())
{
var url = "https://localhost:44307/api/books/";
return(Redirect(url + newBook.Id));
}
return(Ok("Was not saved"));
//var path = "D:/Employee_Report - Copy.pdf";
//Book viewBook = new Book()
//{
// Author = "Dimitar C.",
// FilePathToBook = "D:/Employee_Report - Copy.pdf",
// ByteBook = System.IO.File.ReadAllBytes(path),
// Title = "Employee_Report - Copy"
//};
// From File to Byte[]
// return new EmptyResult();
//return Ok();
// return new HttpStatusCodeResult(204);
}
/// <summary>
/// Finds books by one of available tags
/// </summary>
/// <param name="tagName">Tag name</param>
/// <param name="tagValue">Tag value</param>
/// <returns>List of found books</returns>
public List <Book> FindBookByTag(BookTags tagName, string tagValue)
{
if (tagValue == null)
{
bookLogger.Error($"There was an attempt to enter a null tag");
throw new ArgumentNullException("Tag value can't be null.");
}
if (tagValue == string.Empty)
{
bookLogger.Error($"There was an attempt to enter an empty tag");
throw new ArgumentException("Tag value can't be empty.");
}
List <Book> foundBooks = new List <Book>();
int tagDigitalValue;
switch (tagName)
{
case BookTags.Isbn:
foreach (Book book in this.AllBooks)
{
if (book.Isbn == int.Parse(tagValue))
{
foundBooks.Add(book);
}
}
break;
case BookTags.Author:
foreach (Book book in this.AllBooks)
{
if (book.Author == tagValue)
{
foundBooks.Add(book);
}
}
break;
case BookTags.Name:
foreach (Book book in this.AllBooks)
{
if (book.Name == tagValue)
{
foundBooks.Add(book);
}
}
break;
case BookTags.Edition:
tagDigitalValue = this.GetTagValueDigitalRepresentation(tagValue);
foreach (Book book in this.AllBooks)
{
if (book.Edition == tagDigitalValue)
{
foundBooks.Add(book);
}
}
break;
case BookTags.EditionYear:
tagDigitalValue = this.GetTagValueDigitalRepresentation(tagValue);
foreach (Book book in this.AllBooks)
{
if (book.EditionYear == tagDigitalValue)
{
foundBooks.Add(book);
}
}
break;
case BookTags.Pages:
tagDigitalValue = this.GetTagValueDigitalRepresentation(tagValue);
foreach (Book book in this.AllBooks)
{
if (book.Pages == tagDigitalValue)
{
foundBooks.Add(book);
}
}
break;
case BookTags.Price:
double tagValuePrice;
try
{
tagValuePrice = double.Parse(tagValue);
}
catch
{
bookLogger.Error("There was an attempt to convert string to double, but it failed due to invalid double value.");
throw new ArgumentException("Invalid double value.");
}
foreach (Book book in this.AllBooks)
{
if (book.Price == tagValuePrice)
{
foundBooks.Add(book);
}
}
break;
}
return(foundBooks);
}
/// <summary>
/// Finds books by one of available tags
/// </summary>
public List <Book> FindBookByTag(BookTags tagName, string tagValue)
{
if (tagValue == null)
{
throw new ArgumentNullException("Tag value can't be null.");
}
if (tagValue == "")
{
throw new ArgumentException("Tag value can't be empty.");
}
List <Book> foundBooks = new List <Book>();
int tagDigitalValue;
switch (tagName)
{
case BookTags.isbn:
foreach (Book book in AllBooks)
{
if (book.Isbn == int.Parse(tagValue))
{
foundBooks.Add(book);
}
}
break;
case BookTags.author:
foreach (Book book in AllBooks)
{
if (book.Author == tagValue)
{
foundBooks.Add(book);
}
}
break;
case BookTags.name:
foreach (Book book in AllBooks)
{
if (book.Name == tagValue)
{
foundBooks.Add(book);
}
}
break;
case BookTags.edition:
tagDigitalValue = GetTagValueDigitalRepresentation(tagValue);
foreach (Book book in AllBooks)
{
if (book.Edition == tagDigitalValue)
{
foundBooks.Add(book);
}
}
break;
case BookTags.editionYear:
tagDigitalValue = GetTagValueDigitalRepresentation(tagValue);
foreach (Book book in AllBooks)
{
if (book.EditionYear == tagDigitalValue)
{
foundBooks.Add(book);
}
}
break;
case BookTags.pages:
tagDigitalValue = GetTagValueDigitalRepresentation(tagValue);
foreach (Book book in AllBooks)
{
if (book.Pages == tagDigitalValue)
{
foundBooks.Add(book);
}
}
break;
case BookTags.price:
double tagValuePrice;
try
{
tagValuePrice = double.Parse(tagValue);
}
catch
{
throw new ArgumentException("Invalid double value.");
}
foreach (Book book in AllBooks)
{
if (book.Price == tagValuePrice)
{
foundBooks.Add(book);
}
}
break;
}
return(foundBooks);
}
/// <summary>
/// Finds book by tag.
/// </summary>
/// <param name="tag">Tag</param>
/// <param name="value">Tag value</param>
/// <returns></returns>
public List <Book> FindBookByTag(BookTags tag, string value)
{
_ = value ?? throw new ArgumentException("Value should not be null", nameof(value));
List <Book> searchResult = new List <Book>();
switch (tag)
{
case BookTags.Id:
if (int.TryParse(value, out var id))
{
searchResult = bookListStorage.Books.Where(b => b.Id == id).ToList();
}
break;
case BookTags.ISBN:
searchResult = bookListStorage.Books.Where(b => b.ISBN == value).ToList();
break;
case BookTags.Author:
searchResult = bookListStorage.Books.Where(b => b.Author == value).ToList();
break;
case BookTags.Title:
searchResult = bookListStorage.Books.Where(b => b.Title == value).ToList();
break;
case BookTags.Publisher:
searchResult = bookListStorage.Books.Where(b => b.Publisher == value).ToList();
break;
case BookTags.YearPublished:
if (DateTime.TryParseExact(value, DateFormat, CultureInfo.InvariantCulture, DateTimeStyles.None, out var year))
{
searchResult = bookListStorage.Books.Where(b => b.YearPublished == year).ToList();
}
break;
case BookTags.Pages:
if (int.TryParse(value, out var pages))
{
searchResult = bookListStorage.Books.Where(b => b.Pages == pages).ToList();
}
break;
case BookTags.Price:
if (double.TryParse(value, out var price))
{
searchResult = bookListStorage.Books.Where(b => b.Price == price).ToList();
}
break;
default:
break;
}
return(searchResult);
}
