public IActionResult EditWish(string id)
{
UsersBooks book = _context.UsersBooks.Where(b => b.Id == int.Parse(id)).FirstOrDefault();
return(View(book));
}
public void RequestBorrowBook(string borrower, string lender, Guid bookId)
{
if (borrower == null || lender == null || bookId == null || borrower == lender)
{
throw new Exception("Cannot make request");
}
using (var context = new ApplicationDbContext())
{
UsersBooks userbook = context.UsersBooks.FirstOrDefault(x => x.BookId == bookId && x.UserId == lender);
if (userbook == null)
{
throw new Exception("User does not own this book");
}
if (userbook.Borrowed || userbook.Lent)
{
throw new Exception("Book is borrowed or lent, cannot make request");
}
BorrowRequest request = new BorrowRequest()
{
BookId = bookId,
BorrowerId = borrower,
LenderId = lender
};
context.BorrowRequests.Add(request);
context.SaveChanges();
}
}
public IActionResult Delete(string id)
{
UsersBooks book = _context.UsersBooks.Where(b => b.Id == int.Parse(id)).FirstOrDefault();
_context.UsersBooks.Remove(book);
_context.SaveChanges();
return(RedirectToAction("ReadingList", "Readers"));
}
public User BorrowBook(string firstName, string middleName, string lastName, string bookTitle)
{
this.validations.UserValidation(firstName, middleName, lastName);
this.validations.BookTitleValidation(bookTitle);
var user = this.context.Users
.Include(u => u.Address)
.ThenInclude(a => a.Town)
.Include(u => u.UsersBooks)
.ThenInclude(ub => ub.Book)
.SingleOrDefault(u => u.FirstName == firstName &&
u.MiddleName == middleName &&
u.LastName == lastName);
if (user == null)
{
throw new UserNullableException("There is no such user in this Library.");
}
var bookForBorrow = this.context.Books
.Include(a => a.Author)
.Include(g => g.Genre)
.FirstOrDefault(b => b.Title == bookTitle);
if (bookForBorrow == null)
{
throw new AddBookNullableExeption("There is no such book in this Library");
}
if (bookForBorrow.BooksInStore - 1 < 0)
{
throw new AddBookNullableExeption("There is no enough books in store");
}
var isBorrow = this.context.UsersBooks
.Select(b => b)
.Where(b => b.BookId == bookForBorrow.Id && b.UserId == user.Id).ToList();
if (isBorrow.Count != 0)
{
throw new AddBookNullableExeption($"User {firstName} already borrow this book '{bookTitle}'.");
}
bookForBorrow.BooksInStore--;
var usersBooks = new UsersBooks
{
User = user,
Book = bookForBorrow
};
user.UsersBooks.Add(usersBooks);
this.context.SaveChanges();
return(user);
}
public async Task <IActionResult> AddWishAsync(UsersBooks usersBooks)
{
IdentityUser user = await _userManager.GetUserAsync(User);
UsersBooks book = usersBooks;
book.User = user;
_context.UsersBooks.Add(book);
await _context.SaveChangesAsync();
return(RedirectToAction("ReadingWishList", "Readers"));
}
public async Task <IActionResult> Edit(UsersBooks usersBooks)
{
IdentityUser user = await _userManager.GetUserAsync(User);
UsersBooks book = usersBooks;
book.User = user;
book.HasRead = true;
_context.UsersBooks.Update(book);
_context.SaveChanges();
return(RedirectToAction("ReadingList", "Readers"));
}
public void AddBookToLibrary(string UserId, Guid BookId, bool Public = true)
{
using (var context = new ApplicationDbContext())
{
UsersBooks UserBookEntry = new UsersBooks()
{
BookId = BookId,
UserId = UserId,
Public = Public,
Borrowed = false,
Lent = false
};
ApplicationUser user = context.Users.Include(x => x.Books).FirstOrDefault(x => x.Id == UserId);
if (user == null)
{
_logger.Warn($"BookService/AddBookToLibrary Could not find user with Id={UserId}");
throw new Exception("User with given ID does not exist");
}
Book book = context.Books.Include(x => x.Owners).FirstOrDefault(x => x.Id == BookId);
if (book == null)
{
_logger.Warn($"BookService/AddBookToLibrary Could not find book with Id={BookId}");
throw new Exception("Book with given ID does not exist");
}
var addResult = context.UsersBooks.Add(UserBookEntry);
if (addResult == null)
{
_logger.Warn($"BookService/AddBookToLibrary Could not add book with Id={BookId} to User with Id={UserId} library.");
throw new Exception("Could not add book to library.");
}
user.Books.Add(UserBookEntry);
book.Owners.Add(UserBookEntry);
_logger.Debug($"BookService/AddBookToLibrary Book (Id={BookId}) added to User (Id={UserId}) library");
Activity activity = new Activity()
{
Id = Guid.NewGuid(),
OwnerId = UserId,
TimeStampUTC = DateTime.Now.ToUniversalTime(),
Type = ActivityType.AddedBook,
BookId = BookId
};
context.Activities.Add(activity);
context.SaveChanges();
}
}
public ActionResult <UsersBooks> AddUsersBook(UsersbooksDTO usersbookDTO)
{
if (_context.Books.Any(x => x.Title == usersbookDTO.BookTitle) == false)
{
var bookToCreate = new Book
{
Title = usersbookDTO.BookTitle,
Author = GetAuthor(usersbookDTO.BookTitle),
WantEchangeAmmount = 0,
WantGetAmmount = 0
};
if (bookToCreate.Author == null)
{
Log.Information("No Author was found for given bookTitle");
return(BadRequest("Book doesnt exist"));
}
_context.Books.Add(bookToCreate);
_context.SaveChanges();
}
var book = _context.Books.FirstOrDefault(x => x.Title == usersbookDTO.BookTitle);
var user = _context.Users.FirstOrDefault(x => x.Username == usersbookDTO.Username);
var usersbooksToCreate = new UsersBooks
{
UserId = user.Id,
BookId = book.Id,
WantEchange = usersbookDTO.WantExchange,
WantGet = usersbookDTO.WantGet
};
_context.UsersBooks.Add(usersbooksToCreate);
_context.SaveChanges();
if (usersbookDTO.WantExchange == true)
{
book.WantEchangeAmmount += 1;
_context.Books.Update(book);
_context.SaveChanges();
}
if (usersbookDTO.WantGet == true)
{
book.WantGetAmmount += 1;
_context.Books.Update(book);
_context.SaveChanges();
}
return(Ok(usersbooksToCreate));
}
public async Task <IActionResult> PostUsersBooks([FromBody] UsersBooks usersBooks)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (usersBooks.UsersId.ToString() != AppConfig.getTokenClaims(HttpContext, ClaimTypes.NameIdentifier) &&
AppConfig.getTokenClaims(HttpContext, ClaimTypes.Role) != "admin"
)
{
return(BadRequest());
}
bool isUser = _context.Users.Any((Users u) => u.Id == usersBooks.UsersId);
bool isBook = _context.Books.Any((Books b) => b.Id == usersBooks.BooksId);
try
{
if (isUser && isBook)
{
_context.UsersBooks.Add(usersBooks);
}
else
{
throw new Exception($"books {usersBooks.BooksId} or user {usersBooks.UsersId} does not exists");
}
await _context.SaveChangesAsync();
await _context.SaveChangesAsync();
}
catch (DbUpdateException)
{
if (UsersBooksExists(usersBooks.Id))
{
return(new StatusCodeResult(StatusCodes.Status409Conflict));
}
else
{
throw;
}
}
return(CreatedAtAction("GetUsersBooks", new { id = usersBooks.Id }, usersBooks));
}
public void CreateOrUpdate(BUsersBook userBook)
{
if (userBook.Id == 0)
{
UsersBooks duserBook = new UsersBooks()
{
BooksId = userBook.BooksId, UserId = userBook.UserId, DateOrder = userBook.DateOrder
};
Database.UsersBooks.Create(duserBook);
}
else
{
UsersBooks editUserBook = AutoMapper <BUsersBook, UsersBooks> .Map(userBook);
Database.UsersBooks.Update(editUserBook);
}
Database.Save();
}
public async Task <IActionResult> PutUsersBooks([FromRoute] int id, [FromBody] UsersBooks usersBooks)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != usersBooks.Id)
{
return(BadRequest());
}
if (!(AppConfig.getTokenClaims(HttpContext, ClaimTypes.NameIdentifier) == usersBooks.UsersId.ToString()) &&
AppConfig.getTokenClaims(HttpContext, ClaimTypes.Role) != "admin"
)
{
return(BadRequest());
}
_context.Entry(usersBooks).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!UsersBooksExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public bool CheckUser(int id)
{
UsersBooks usersBooks = Database.UsersBooks.Find(i => i.UserId == id && i.DateOrder <= DateTime.Now).FirstOrDefault();
return((usersBooks == null) ? true : false);
}
public void AcceptBorrowBookRequest(string requester, string borrowFromId, Guid bookId)
{
if (requester == borrowFromId)
{
throw new Exception("Cannot borrow from self.");
}
using (var context = new ApplicationDbContext())
{
UsersBooks userBook = context.UsersBooks.FirstOrDefault(x => x.BookId == bookId && x.UserId == borrowFromId);
if (userBook == null)
{
//LOG
throw new Exception("Cannot find UserBook");
}
var book = context.Books.FirstOrDefault(x => x.Id == bookId);
ApplicationUser borrower = context.Users.FirstOrDefault(x => x.Id == requester);
if (borrower == null)
{
throw new Exception("Borrower does not exist");
}
userBook.Lent = true;
userBook.LentToId = borrower.Id;
userBook.LentTo = borrower;
ApplicationUser borrowFrom = context.Users.FirstOrDefault(x => x.Id == borrowFromId);
if (borrowFrom == null)
{
throw new Exception("BorrowFrom does not exist");
}
var newUserBook = new UsersBooks()
{
BookId = bookId,
UserId = borrower.Id,
Public = true,
Borrowed = true,
BorrowedFrom = borrowFrom,
BorrowedFromId = borrowFromId,
Lent = false,
Book = book
};
context.UsersBooks.Add(newUserBook);
BorrowRequest request = context.BorrowRequests.FirstOrDefault(x => x.BookId == bookId && x.BorrowerId == requester && x.LenderId == borrowFromId);
context.BorrowRequests.Remove(request);
Activity activity = new Activity()
{
Id = Guid.NewGuid(),
BookId = book.Id,
OwnerId = requester,
TimeStampUTC = DateTime.Now.ToUniversalTime(),
Type = ActivityType.BorrowedBook
};
context.Activities.Add(activity);
context.SaveChanges();
}
}
