public void AddAuthors(IEnumerable <Author> authors)
{
foreach (var author in authors)
{
BookAuthors.Add(new BookAuthor(this, author));
}
}
internal bool Delete(BookAuthors cs)
{
string sql = "DELETE FROM bookauthors WHERE authorId = @AuthorId AND bookId = @bookId";
int deleted = _db.Execute(sql, cs);
return(deleted == 1);
}
public void AddAuthors(IEnumerable <Int32> authors)
{
foreach (var authorId in authors)
{
BookAuthors.Add(new BookAuthor(this, authorId));
}
}
public override string ToString()
{
var output = $"{Id} {Title} ";
output = BookAuthors.Aggregate(output, (current, author) => current + $"{author.Author.FirstName} {author.Author.LastName} ");
return(Genres.Aggregate(output, (current, genre) => current + $"{genre.Genre.Name} "));
}
public async Task <IActionResult> Edit(int id, [Bind("Id,BookId,AuthorId")] BookAuthors bookAuthors)
{
if (id != bookAuthors.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(bookAuthors);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!BookAuthorsExists(bookAuthors.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["AuthorId"] = new SelectList(_context.Authors, "Id", "AuthorName", bookAuthors.AuthorId);
ViewData["BookId"] = new SelectList(_context.Books, "Id", "Name", bookAuthors.BookId);
return(View(bookAuthors));
}
public async Task <IActionResult> PutBookAuthors(long id, BookAuthors bookAuthors)
{
if (id != bookAuthors.BookId)
{
return(BadRequest());
}
_context.Entry(bookAuthors).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!BookAuthorsExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public List <BookAuthors> Find(int?id)
{
List <BookAuthors> bookAuthors = new List <BookAuthors>();
using (SqlConnection conn = new SqlConnection(CONNECTION_STR))
{
conn.Open();
SqlCommand cmd = conn.CreateCommand();
cmd.CommandText = @"Select * from BookAuthors where book = @book";
cmd.Parameters.Add(new SqlParameter("@book", id));
SqlDataAdapter sqlDA = new SqlDataAdapter(cmd);
DataSet ds = new DataSet();
sqlDA.Fill(ds, "bookAuthorsList");
foreach (DataRow row in ds.Tables["bookAuthorsList"].Rows)
{
BookAuthors b = new BookAuthors();
b.AuthorID = (int)row["author"];
b.BookID = (int)row["book"];
b.Name = (string)row["name"];
bookAuthors.Add(b);
}
}
return(bookAuthors);
}
public async Task <IActionResult> PostBookAuthors([FromBody] BookAuthors bookAuthors)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_context.BookAuthors.Add(bookAuthors);
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateException)
{
if (BookAuthorsExists(bookAuthors.Book.Id))
{
return(new StatusCodeResult(StatusCodes.Status409Conflict));
}
else
{
throw;
}
}
return(CreatedAtAction("GetBookAuthors", new { id = bookAuthors.Book.Id }, bookAuthors));
}
public IEnumerable <BookModel> GetBooks()
{
var books = Books.Get()?.ToList();
if (books == null || !books.Any())
{
return(Enumerable.Empty <BookModel>().ToList());
}
var pubHouseIds = books.Select(t => t.PubHouseId);
var pubHouses = PubHouses.Get().Where(t => pubHouseIds.Contains(t.PubHouseId));
var bookIds = books.Select(t => t.BookId);
var authors = BookAuthors.Get().Where(t => bookIds.Contains(t.BookId)).Join(Authors.Get(),
ba => ba.AuthorId,
a => a.AuthorId,
(ba, a) =>
new
{
ba.BookId,
author = a
});
var list = new List <BookModel>();
books.ForEach(t =>
{
var thisBookAuthors = authors.Where(a => a.BookId == t.BookId).Select(q => q.author).ToList();
var pubHouse = pubHouses.SingleOrDefault(p => p.PubHouseId == t.PubHouseId);
list.Add(new BookModel(t, thisBookAuthors, pubHouse));
});
return(list);
}
internal String Delete(BookAuthors cs)
{
if (_repo.Delete(cs))
{
return("Successfully Deleted");
}
throw new Exception("Invalid Id");
}
public void DeleteAuthor(long id)
{
if (BookAuthors.Get().Any(t => t.AuthorId == id))
{
throw new InvalidOperationException();
}
Authors.Delete(id);
}
public long Add(BookAuthors t)
{
long id = (_items.Any() ? _items.Max(a => a.BookAuthorId) : 0) + 1;
t.BookAuthorId = id;
_items.Add(t);
return(id);
}
private void OnAuthorRemoved(Author removedAuthor)
{
BookAuthor baRecord = BookAuthors.SingleOrDefault(ba => ba.Book == this && ba.Author == removedAuthor);
if (baRecord != null)
{
baRecord.Remove( );
}
}
internal BookAuthors Create(BookAuthors newBookAuthors)
{
BookAuthors created = _repo.Create(newBookAuthors);
if (created == null)
{
throw new Exception("Create Request Failed");
}
return(created);
}
public void AddBookAuthors(int bookId, List <int> authorsId)
{
foreach (int authorId in authorsId)
{
BookAuthors bookAuthor = new BookAuthors();
bookAuthor.BookId = bookId;
bookAuthor.AuthorId = authorId;
bookAuthorsRepository.Create(bookAuthor);
}
}
internal BookAuthors Get(int id)
{
BookAuthors found = _repo.Get(id);
if (found == null)
{
throw new Exception("Invalid Id");
}
return(found);
}
public void Update(Book b)
{
bookAuthorsDAO.Delete(b);
foreach (var author in b.Authors)
{
BookAuthors bookAuthor = new BookAuthors();
bookAuthor.AuthorID = author.Id;
bookAuthor.BookID = b.Id;
bookAuthor.Name = author.Name;
bookAuthorsDAO.Create(bookAuthor);
}
using (SqlConnection conn = new SqlConnection(CONNECTION_STR))
{
conn.Open();
SqlCommand cmd = conn.CreateCommand();
cmd.CommandText = @"Update Books Set Title=@title, ISBN=@ISBN, Genre=@genre, bookLanguage=@language, bookDescription=@description Where Id=@id";
cmd.Parameters.Add(new SqlParameter("@title", b.Title));
cmd.Parameters.Add(new SqlParameter("@id", b.Id));
if (b.ISBN == null)
{
cmd.Parameters.Add(new SqlParameter("@ISBN", ""));
}
else
{
cmd.Parameters.Add(new SqlParameter("@ISBN", b.ISBN));
}
if (b.GenreID == -1)
{
cmd.Parameters.Add(new SqlParameter("@genre", DBNull.Value));
}
else
{
cmd.Parameters.Add(new SqlParameter("@genre", b.GenreID));
}
cmd.Parameters.Add(new SqlParameter("@language", b.LanguageID));
if (b.Description == null)
{
cmd.Parameters.Add(new SqlParameter("@description", ""));
}
else
{
cmd.Parameters.Add(new SqlParameter("@description", b.Description));
}
try
{
cmd.ExecuteScalar();
}
catch (SqlException e)
{
Console.Write(e.StackTrace);
}
}
}
public ActionResult AddAuthorsToBook(int bookId, int authorId)
{
if (bookId == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
List <Author> authorList = db.Authors.ToList();
if (authorId != 0)
{
Book book = db.Books.Find(bookId);
List <BookAuthors> bookAuthorses = new List <BookAuthors>();
// bookAuthorses = db.BookAuthors.Where(a => a.BookId == bookId).ToList();
ViewBag.BookId = book.BookId;
int bookID = book.BookId;
BookAuthors bookAuthor = new BookAuthors();
bookAuthor.BookId = bookID;
bookAuthor.AuthorId = authorId;
// book.Authors.Where(a=>a.Id==bookAuthor.AuthorId).Count()
if (book.Authors == null)
{
// Author author = db.Authors.Where(a => a.Id == bookAuthor.AuthorId).Single();
//int authorIdTest = db.Authors.Where(a => a.Id == bookAuthor.AuthorId).Single().Id;
// book.Authors.Add(author);
var testi = db.BookAuthors.Where(a => a.BookId == bookID).ToList();
var testi2 = testi.Select(a => a.AuthorId).Contains(bookAuthor.AuthorId);
// db.Books.AddOrUpdate(book);
if (!testi2)//!db.BookAuthors.Select(a=>a.AuthorId).Contains(bookAuthor.AuthorId)
{
db.BookAuthors.Add(bookAuthor);
}
// db.BookAuthors.Distinct();
db.SaveChanges();
}
db.BookAuthors.Distinct();
db.SaveChanges();
}
var ListOfBookAuthors = db.BookAuthors.Where(a => a.BookId == bookId).ToList();
List <Author> ListOfAuthors = new List <Author>();
foreach (var author in ListOfBookAuthors)
{
ListOfAuthors.Add(author.Author);
}
ViewBag.ListOfAuthors = ListOfAuthors;
return(View(authorList));
}
public ActionResult <BookAuthors> Create([FromBody] BookAuthors newBookAuthors)
{
try
{
return(Ok(_bs.Create(newBookAuthors)));
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
[HttpPut] // api/bookauthors/:bookAuthorId
public ActionResult <BookAuthors> Delete([FromBody] BookAuthors toRemove)
{
try
{
return(Ok(_bs.Delete(toRemove)));
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
public void DeleteCurrentBookAuthors(Book book)
{
var currentAuthors = BookAuthors.List(new QueryOptions <BookAuthor>
{
Where = ba => ba.BookId == book.BookId
});
foreach (BookAuthor ba in currentAuthors)
{
BookAuthors.Delete(ba);
}
}
protected void SearchBtn_Click(object sender, EventArgs e)
{
string termToSearch = SearchText.Text;
if (!string.IsNullOrEmpty(termToSearch))
{
List <Author> authors = GetAllAuthors();
List <Author> filteredAuthors = authors.Where(author => author.AuthorName.Contains(termToSearch)).ToList();
BookAuthors.DataSource = filteredAuthors;
BookAuthors.DataBind();
}
}
public void Create(Book b)
{
using (SqlConnection conn = new SqlConnection(CONNECTION_STR))
{
conn.Open();
SqlCommand cmd = conn.CreateCommand();
cmd.CommandText = "Insert Into Books Values (@title, @ISBN, @genre, @language, @description)";
cmd.Parameters.Add(new SqlParameter("@title", b.Title));
if (b.ISBN == null)
{
cmd.Parameters.Add(new SqlParameter("@ISBN", ""));
}
else
{
cmd.Parameters.Add(new SqlParameter("@ISBN", b.ISBN));
}
if (b.Genre.Id == -1)
{
cmd.Parameters.Add(new SqlParameter("@genre", DBNull.Value));
}
else
{
cmd.Parameters.Add(new SqlParameter("@genre", b.GenreID));
}
cmd.Parameters.Add(new SqlParameter("@language", b.LanguageID));
if (b.Description == null)
{
cmd.Parameters.Add(new SqlParameter("@description", ""));
}
else
{
cmd.Parameters.Add(new SqlParameter("@description", b.Description));
}
try
{
cmd.ExecuteNonQuery();
}
catch (SqlException e)
{
Console.Write(e.StackTrace);
}
foreach (var author in b.Authors)
{
BookAuthors bookAuthor = new BookAuthors();
bookAuthor.AuthorID = author.Id;
bookAuthor.BookID = b.Id;
bookAuthor.Name = author.Name;
bookAuthorsDAO.Create(bookAuthor);
}
}
}
public BookModel GetBook(long id)
{
var book = Books.GetById(id);
var pubHouse = book.PubHouseId.HasValue ? PubHouses.GetById(book.PubHouseId.Value) : null;
var authors = Authors.Get()
.Join(BookAuthors.Get().Where(q => q.BookId == book.BookId), a => a.AuthorId, ba => ba.AuthorId, (a, ba) =>
a).ToList();
var bookModel = new BookModel(book, authors, pubHouse);
return(bookModel);
}
internal BookAuthors Create(BookAuthors newBookAuthors)
{
string sql = @"
INSERT INTO bookauthors
(authorId, bookId)
VALUES
(@AuthorId, @BookId);
SELECT LAST_INSERT_ID();
";
newBookAuthors.Id = _db.ExecuteScalar <int>(sql, newBookAuthors);
return(newBookAuthors);
}
public ActionResult InsertBook(InsertBookViewModel insertBookViewModel)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
if (insertBookViewModel.Title == null || insertBookViewModel.CategoryId < 1 || insertBookViewModel.AuthorIds == null)
{
return(BadRequest("Add more information"));
}
if (insertBookViewModel.BookBuyOnlineId == null && insertBookViewModel.BookBuyOffileId == null)
{
return(BadRequest("Insert book buy Id"));
}
Book book = new Book();
book.BookBuyOffileId = insertBookViewModel.BookBuyOffileId;
book.BookBuyOnlineId = insertBookViewModel.BookBuyOnlineId;
book.CategoryId = insertBookViewModel.CategoryId;
book.PublisherId = insertBookViewModel.PublisherId;
book.Deleted = false;
book.Title = insertBookViewModel.Title;
if (insertBookViewModel.AuthorIds != null)
{
book.BookAuthors = insertBookViewModel.AuthorIds.Select((authorId) =>
{
BookAuthors bookAuthors = new BookAuthors();
bookAuthors.UserId = authorId;
return(bookAuthors);
}).ToList();
}
try
{
_iBookService.Create(book);
}
catch (Exception)
{
return(BadRequest("Input Wrong ID"));
}
return(Ok());
}
public void AddBook(BookModel book)
{
var id = Books.Add(new Book
{
PubHouseId = book.PubHouseId,
PublishYear = book.PublishYear,
NumPages = book.NumPages,
ISBN = book.ISBN,
Title = book.Title
});
book.Authors.ForEach(t =>
BookAuthors.Add(new BookAuthors {
BookId = id, AuthorId = t
}));
}
public ActionResult InsertBook(InsertBookViewModel insertBookViewModel)
{
if (insertBookViewModel.Title == null || insertBookViewModel.CategoryId < 1 || insertBookViewModel.AuthorIds == null)
{
return(BadRequest("Add more information"));
}
if (insertBookViewModel.BookBuyOnlineId == null && insertBookViewModel.BookBuyOffileId == null)
{
return(BadRequest("Insert book buy Id"));
}
List <string> authors = insertBookViewModel.AuthorIds;
Book book = new Book();
book.BookBuyOffileId = insertBookViewModel.BookBuyOffileId;
book.BookBuyOnlineId = insertBookViewModel.BookBuyOnlineId;
book.CategoryId = insertBookViewModel.CategoryId;
book.PublisherId = insertBookViewModel.PublisherId;
book.Deleted = false;
book.Title = insertBookViewModel.Title;
_context.Book.Add(book);
foreach (string authorId in authors)
{
BookAuthors bookAuthors = new BookAuthors();
bookAuthors.BookId = book.Id;
bookAuthors.UserId = authorId;
bookAuthors.CreatedDate = new DateTime();
try
{
_context.BookAuthors.Add(bookAuthors);
}
catch (Exception)
{
return(BadRequest("Check your input"));
}
}
_context.SaveChanges();
return(Ok());
}
public async Task <IActionResult> Create(int authorId, [Bind("Id,BookId")] BookAuthors bookAuthors)
{
BookAuthors ba = new BookAuthors();
ba.AuthorId = authorId;
bookAuthors.AuthorId = authorId;
ba.BookId = bookAuthors.BookId;
if (ModelState.IsValid)
{
_context.Add(ba);
await _context.SaveChangesAsync();
return(RedirectToAction("Index", new { id = authorId }));
}
//ViewData["AuthorId"] = new SelectList(_context.Authors, "Id", "AuthorName", bookAuthors.AuthorId);
ViewData["BookId"] = new SelectList(_context.Books, "Id", "Name", bookAuthors.BookId);
return(View("Index", new { id = authorId }));
}
/// <inheritdoc />
/// <summary>
/// Jedes Buch muss zumindest einen Autor haben.
/// Weiters darf ein Autor einem Buch nicht mehrfach zugewiesen
/// werden.
/// </summary>
/// <param name="validationContext"></param>
/// <returns></returns>
public IEnumerable <ValidationResult> Validate(ValidationContext validationContext)
{
if (BookAuthors.Count == 0)
{
yield return(new ValidationResult("Book must have at least one author"));
}
var doubleAuthorNames = BookAuthors
.GroupBy(ba => ba.Author)
.Where(baGroup => baGroup.Count() > 1)
.Select(baGroup => baGroup.Key.Name)
.ToArray()
.Join();
if (doubleAuthorNames.Length > 0)
{
yield return(new ValidationResult($"{doubleAuthorNames} are twice authors of the book"));
}
}
