public async Task <IHttpActionResult> DeleteBook(int id)
{
try {
string userId = User.Identity.GetUserId();
UserBook userBook = await db.UserBooks.Include("Book").FirstOrDefaultAsync(ub => ub.Id == id);
if (userBook == null)
{
return(NotFound());
}
if (userBook.UserId != userId)
{
return(BadRequest("User does not own the book."));
}
if (userBook.Book.CanBeUpdatedBy(userId))
{
db.Books.Remove(userBook.Book);
// . all user books will be deleted cascadely
}
else
{
// . remove only user book
db.UserBooks.Remove(userBook);
}
await db.SaveChangesAsync();
return(Ok(userBook));
} catch (Exception e) {
_logger.Error(e, "Can not delete user book");
throw;
}
}
public async Task <IActionResult> Edit(int id, [Bind("BookId,UserId,Rating")] UserBook userBook)
{
if (id != userBook.BookId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(userBook);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!UserBookExists(userBook.BookId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["BookId"] = new SelectList(_context.Books, "Id", "Author", userBook.BookId);
return(View(userBook));
}
public void AddNotification_Should_Success_When_NewChapter_Added()
{
var user1 = new BookCreatorUser()
{
UserName = "******",
Name = "Gosho Goshev"
};
var user2 = new BookCreatorUser()
{
UserName = "******",
Name = "Ivan Ivanov"
};
var book = new Book()
{
Id = "1",
Title = "title1",
Summary = "summary1",
CreatedOn = DateTime.UtcNow,
ImageUrl = GlobalConstants.NoImageAvailableUrl,
Genre = new BookGenre()
{
Genre = "Horror"
},
AuthorId = "111"
};
var userBook1 = new UserBook()
{
UserId = user1.Id,
BookId = book.Id
};
var userBook2 = new UserBook()
{
UserId = user2.Id,
BookId = book.Id
};
book.Followers.Add(userBook1);
book.Followers.Add(userBook2);
userManager.CreateAsync(user1).GetAwaiter();
userManager.CreateAsync(user2).GetAwaiter();
this.Context.Books.Add(book);
this.Context.UsersBooks.Add(userBook1);
this.Context.UsersBooks.Add(userBook2);
this.Context.SaveChanges();
this.notificationService.AddNotification(book.Id, null, book.Title);
var result = this.Context.UsersBooks.ToList();
result.Should().NotBeEmpty().And.HaveCount(2);
result[0].User.Should().BeEquivalentTo(user1);
result[1].User.Should().BeEquivalentTo(user2);
}
public ReviewBook PutReview(ReviewBook reviewBook)
{
var _userId = User.FindFirstValue(ClaimTypes.NameIdentifier);
var entity = _context.UserBooks.SingleOrDefault(item => item.Id == reviewBook.Id && item.UserId == _userId);
if (entity == null)
{
UserBook newBook = new UserBook
{
Id = reviewBook.Id,
Review = reviewBook.Review,
ReviewedOn = DateTime.Now,
UserId = _userId
};
_context.UserBooks.Add(newBook);
}
else
{
entity.Review = reviewBook.Review;
entity.ReviewedOn = DateTime.Now;
}
try
{
_context.SaveChanges();
}
catch (DbUpdateException)
{
throw;
}
return(reviewBook);
}
public ActionResult AddToBook(int id)
{
var us = (User)Session["User"];
User user = db.Users.Find(us.Id);
if (user.UserBooks == null)
{
user.UserBooks = new List <UserBook>();
}
if (user.UserBooks.Any(x => x.Book.Id == id))
{
return(RedirectToAction("Index", "Library", new { error = "Bu kitap kitaplığınızda mevcuttur." }));
}
else
{
var u = db.Users.Find(user.Id);
Book choosenBook = db.Books.Find(id);
UserBook newBook = new UserBook();
newBook.Book = choosenBook;
newBook.User = u;
u.UserBooks.Add(newBook);
db.Entry(u).State = EntityState.Modified;
db.Entry(choosenBook).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index", "Library"));
}
;
}
// POST api/Book
public async Task <IHttpActionResult> PostBook(BookDto bookDto)
{
if (ModelState.IsValid)
{
LanguageType bookLanguage;
if (!Enum.TryParse <LanguageType>(bookDto.language, out bookLanguage))
{
return(BadRequest("Invalid book language"));
}
var userId = User.Identity.GetUserId();
UserBook userBook = await db.FindUserBookAsync(userId, bookDto.name, bookLanguage);
if (userBook != null)
{
ModelState.AddModelError("name", string.Format("You already have book \"{0}\"", bookDto.name));
}
else
{
userBook = await db.CreateUserBookAsync(User.Identity.GetUserId(), bookLanguage, bookDto.name);
var userBookDto = new UserBookDto(userBook);
return(CreatedAtRoute("DefaultApi", new { id = userBook.Id },
new {
emberDataFormat = true,
books = new List <dynamic> {
userBookDto.BookDto
},
userBooks = new List <dynamic> {
userBookDto
}
}));
}
}
return(new EmberDSErrorsResult(this));
}
public static void UserChoiceOfMenu(int userId, int input)
{
switch (input)
{
case 1:
UserBookCategory.PrintAllCategories(userId);
break;
case 2:
UserBookCategory.SearchForCategories(userId);
break;
case 3:
UserBook.GetBooksInStock(userId);
break;
case 4:
UserBook.SearchForBook(userId);
break;
case 5:
UserBook.GetBooksFromAuthor(userId);
break;
case 6:
Console.WriteLine("Du loggas nu ut.");
api.Logout(userId);
Environment.Exit(0);
break;
default:
Messages.WrongInput();
break;
}
}
public async Task <IActionResult> Edit(int id, [Bind("Id")] UserBook userBook)
{
if (id != userBook.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(userBook);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!UserBookExists(userBook.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(userBook));
}
public void GivenRent_WhenRentBook_NewUserBookAddedWitnStartTimeRent()
{
// Arrange
var userBookToAdd = new UserBook {
BookId = 7, UserId = 7
};
var userBooks = new List <UserBook>();
var userBooksMock = new Mock <IStore <UserBook> >();
var userStoreMock = new Mock <IStore <User> >();
var bookStoreMock = new Mock <IStore <Book> >();
userBooksMock.Setup(m => m.GetAll()).Returns(userBooks);
userBooksMock.Setup(m => m.Add(It.IsAny <UserBook>())).Callback <UserBook>(ub => userBooks.Add(ub));
var library = new Library(userStoreMock.Object, bookStoreMock.Object, userBooksMock.Object);
// Act
library.RentBook(new User {
Id = 7
}, new Book {
Id = 7
});
// Assert
var _userBokkTimeStart = userBooks.Find(ub => ub.UserId == 7 && ub.BookId == 7).RentDateStart;
_userBokkTimeStart.Should().BeCloseTo(DateTime.Now);
}
public void RentBook_WhenRentBook_NewUserBookAdded()
{
// Arrange
var userBookToAdd = new UserBook {
BookId = 7, UserId = 7
};
var userBooks = new List <UserBook>();
var userBooksMock = new Mock <IStore <UserBook> >();
var userStoreMock = new Mock <IStore <User> >();
var bookStoreMock = new Mock <IStore <Book> >();
userBooksMock.Setup(m => m.GetAll()).Returns(userBooks);
userBooksMock.Setup(m => m.Add(It.IsAny <UserBook>())).Callback <UserBook>(ub => userBooks.Add(ub));
var library = new Library(userStoreMock.Object, bookStoreMock.Object, userBooksMock.Object);
// Act
library.RentBook(new User {
Id = 7
}, new Book {
Id = 7
});
// Assert
userBooks.Should()
.ContainSingle(ub => ub.UserId == 7 && ub.BookId == 7 && ub.RentDateStart >= DateTime.Now.AddSeconds(-1));
}
public async Task <ResultModel <UserBook> > EditUserBook(int id, UserBook userBook)
{
var book = await _bookRepository.GetBookByIdAsync(userBook.IdBook);
var userBookFromDB = await _userBookRepository.GetUserBookByIdAsync(id);
if (book != null)
{
book.Amount++;
await _userBookRepository.UpdateUserBookAsync(id, userBook);
await _bookRepository.UpdateBookAsync(book);
return(new ResultModel <UserBook>
{
Data = null,
Success = true,
Message = ""
});
}
else
{
return(new ResultModel <UserBook>
{
Data = null,
Success = false,
Message = "Can't find the book"
});
}
}
public void Insert(int idUser, int idBook)
{
var user = _baseContext.Users.FirstOrDefault(x => x.Id == idUser);
if (user == null)
{
return;
}
var book = _baseContext.Books.FirstOrDefault(x => x.Id == idBook);
if (book == null)
{
return;
}
var userBook = new UserBook
{
Book = book,
User = user,
BookId = idBook,
UserId = idUser
};
if (user.Books == null)
{
user.Books = new List <UserBook>();
}
user.Books.Add(userBook);
_baseContext.SaveChanges();
}
/// <summary>
/// Update my list
/// </summary>
/// <param name="ids">Current my book list</param>
public void UpdateMyBooks(List <int> ids)
{
var user = this.Utils.GetCurrentUser();
var currentMappings = this._databaseContext.UserBookSwitch.Where(x => x.UserId == user.Id).ToList();
foreach (var i in currentMappings)
{
if (ids.FindIndex(x => x == i.BookId) == -1)
{
this._databaseContext.UserBookSwitch.Remove(i);
}
}
foreach (int i in ids)
{
if (currentMappings.FirstOrDefault(x => x.BookId == i) == null)
{
var map = new UserBook()
{
BookId = i, UserId = user.Id, Read = false
};
this._databaseContext.UserBookSwitch.Add(map);
}
}
this._databaseContext.SaveChanges();
this.Logger.LogInformation(user, this.GetService(), this.GetEvent("update my"), ids);
this.Notification.AddStatusLibraryNotificationByType(StatusLibraryNotificationType.MyBookListUpdated, user);
}
public Task <UserBook> CreateUserBookAsync(UserBook obj)
{
ctx.UserBooks.Add(obj);
ctx.SaveChanges();
return(Task.FromResult(obj));
}
public void GiveBorrowedMediaBackRequestTest()
{
//AddBooks(1);
MediaLibContainer context = ContextHelper <MediaLibContainer> .GetCurrentContext();
UserBook book = context.UserMediaSet.OfType <UserBook>().First <UserBook>();
int expectedBookId = book.Id;
MediathekController mediathekController = new MediathekController();
mediathekController.BorrowMediaToUser(fakeUserTo.Identity.Name, book.Id, fakeUserFrom, null);
RedirectToRouteResult result = mediathekController.GiveBorrowedMediaBackRequest(book.Id, fakeUserTo);
IQueryable <UserBook> userBooks = UserMediaService.Instance.GetUserBookByIdAndUserName(fakeUserFrom.Identity.Name, book.Id);
addedUserMedia.Add(userBooks.Single <UserBook>());
Assert.IsNotNull(userBooks);
Assert.AreEqual(expectedBookId, userBooks.Single <UserBook>().Id);
Assert.AreEqual(1, userBooks.Single <UserBook>().BorrowedDetails.Count);
foreach (var detail in userBooks.Single <UserBook>().BorrowedDetails)
{
Assert.AreEqual(true, detail.TakeBackRequest);
}
}
public IActionResult MarkApproved(int orderID)
{
Order order = orderRepository.Orders.FirstOrDefault(o => o.OrderId == orderID);
if (order != null)
{
order.Approved = true;
orderRepository.SaveOrder(order);
}
foreach (var line in order.Lines)
{
UserBook userBook = new UserBook
{
UserName = order.UserName,
Book = line.Book,
Quantity = line.Quantity,
IssuanceDate = DateTime.Now
};
userBookRepository.SaveUserBook(userBook);
line.Book.Available -= line.Quantity;
bookRepository.SaveBook(line.Book);
}
return(RedirectToAction(nameof(List)));
}
/// <summary>
/// Sök efter kategorier
/// </summary>
/// <param name="userId"></param>
public static void SearchForCategories(int userId)
{
api.Ping(userId);
Console.WriteLine("Sök efter: ");
string keyword = Console.ReadLine();
var cat = api.GetCategories(keyword);
foreach (var c in cat)
{
Console.WriteLine($"Resultat:{c.Id} {c.Name}");
}
if (cat.Count == 0)
{
Messages.DoesNotExist();
Console.Clear();
return;
}
Console.WriteLine("Vilken vill du välja?");
try
{
int choice = Convert.ToInt32(Console.ReadLine());
UserBook.GetBooksInCategory(choice, userId);
}
catch
{
Messages.WrongInput();
Console.Clear();
return;
}
}
public void AddBookToUserFavorite([FromBody] UserBook UserBook)
{
if (UserBook.BookId != null && UserBook.UserId != null)
{
BookRepo.AddToList(UserBook.UserId, BookRepo.GetById(UserBook.BookId));
}
}
public FavoriteBook PutFavorite(FavoriteBook favoriteBook)
{
var entity = _context.UserBooks.SingleOrDefault(item => item.Id == favoriteBook.Id && item.UserId == _userId);
if (entity == null)
{
UserBook newBook = new UserBook
{
Id = favoriteBook.Id,
IsFavorite = favoriteBook.IsFavorite,
UserId = _userId
};
_context.UserBooks.Add(newBook);
}
else
{
entity.IsFavorite = favoriteBook.IsFavorite;
}
try
{
_context.SaveChanges();
}
catch (DbUpdateException)
{
throw;
}
return(favoriteBook);
}
public async Task <IActionResult> ReturnBook(string id)
{
if (id == null)
{
return(NotFound());
}
var book = _context.Book.FindAsync(id).Result;
book.IsTaken = false;
var us = await _userManager.GetUserAsync(HttpContext.User);
_context.Update(book);
UserBook userBook = new UserBook
{
BookId = id,
Date = DateTime.Now,
User = us,
Action = "Отдал"
};
_context.Add(userBook);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
public IQueryable <UserBook> GetBookByUserMedia(UserBook media)
{
var books = UserBookDaoEF.Instance.GetByUserMedia(media);
if (!media.Book.Title.Equals(string.Empty))
{
books = books.Where(r => r.Book.Title.Contains(media.Book.Title));
}
if (media.Book.Author.Count != 0)
{
List <UserBook> userBooks = new List <UserBook>();
foreach (var aut in media.Book.Author)
{
List <Author> authors = PersonService.Instance.GetAuthor(aut.LastName).ToList();
foreach (var a in authors)
{
foreach (var book in books)
{
if (book.Book.Author.Contains(a))
{
userBooks.Add(book);
}
}
}
}
return(userBooks.AsQueryable());
}
return(books);
}
public async Task AddBookAsync(AddBookDto addBookDto)
{
Directory.CreateDirectory(ImagesPath);
Directory.CreateDirectory(BookFilesPath);
var imageSaveResult = await SaveAsync(addBookDto.Image, ImagesPath);
var fileSaveResult = await SaveAsync(addBookDto.BookFile, BookFilesPath);
var author = new Author(addBookDto.Author);
_authorRepository.Add(author);
await _unitOfWork.CommitAsync();
var book = new Book(
addBookDto.Name,
author.Id,
addBookDto.GenreId,
imageSaveResult.RelativePath,
fileSaveResult.RelativePath
);
_bookRepository.Add(book);
await _unitOfWork.CommitAsync();
var userBook = new UserBook(book.Id, addBookDto.UserId);
_userBookRepository.Add(userBook);
await _unitOfWork.CommitAsync();
}
public void ReturnBook(ApplicationUser user, Book book, UserBook bookToBeReturned)
{
_context.Entry(user).State = EntityState.Modified;
_context.Entry(book).State = EntityState.Modified;
_context.Entry(bookToBeReturned).State = EntityState.Modified;
_context.SaveChanges();
}
//public int UpdateRating(userBook book)
//{
// userBook bk = context.userBooks.SingleOrDefault(b => b.userBookId == book.userBookId);
// //bk.userId = book.userId;
// //bk.BookId = book.BookId;
// //bk.readStatus = book.readStatus;
// bk.Rating = book.Rating;
// return context.SaveChanges();
//}
//public int UpdateStatus(userBook book)
//{
// userBook bk = context.userBooks.SingleOrDefault(b => b.userBookId == book.userBookId);
// //bk.userId = book.userId;
// //bk.BookId = book.BookId;
// //bk.readStatus = book.readStatus;
// bk.readStatus = book.readStatus;
// return context.SaveChanges();
//}
public UserBook Update(UserBook book, int id)
{
UserBook bk = context.userBooks.SingleOrDefault(b => b.userBookId == id);
if (bk != null)
{
if (book.userId != 0)
{
bk.userId = book.userId;
}
if (book.BookId != 0)
{
bk.BookId = book.BookId;
}
if (book.readStatus != 0)
{
bk.readStatus = book.readStatus;
}
context.SaveChanges();
return(bk);
}
else
{
return(null);
}
}
public void HaveGetAndSet()
{
var userBook = new UserBook();
userBook.UserId = "userid123";
Assert.AreEqual("userid123", userBook.UserId);
}
public void RemoveUserBook(UserBook userBook)
{
var collection = _db.GetCollection <BsonDocument>("Users");
var builder = Builders <BsonDocument> .Filter;
var filter = builder.Eq("bookID", userBook.BookID) & builder.Eq("userID", userBook.UserID);
collection.DeleteOne(filter);
}
public void HaveGetAndSet()
{
var userBook = new UserBook();
userBook.BookId = 5;
Assert.AreEqual(5, userBook.BookId);
}
public void RemoveBookFromUser(User user, Book book)
{
UserBook userBook = db.UsersBooks
.FirstOrDefault(ub => ub.BookId == book.Id && ub.UserId == user.Id);
db.UsersBooks.Remove(userBook);
db.SaveChanges();
}
public void HaveGetAndSet()
{
var userBook = new UserBook();
userBook.BookStatus = BookStatus.CurrentlyReading;
Assert.AreEqual(BookStatus.CurrentlyReading, userBook.BookStatus);
}
private void WantReadButtonClicked(object sender, EventArgs e)
{
Button button = (Button)sender;
BookDataAccess bookDataAccess = new BookDataAccess();
Book bookClass = bookDataAccess.GetBookBySource(Bookphoto.Source.ToString().Replace("Uri: ", ""));
List <UserBook> userBooks = UserBookDataAccess.GetBookByEmailAndBookName(App.UserEmail, bookClass.BookName);
if (userBooks.Count != 0)
{
if (userBooks[0].ReadWant == ReadWantEnum.Want)
{
if (button.Text == "Read")
{
userBooks[0].ReadWant = ReadWantEnum.Read;
userBooks[0].DateTime = DateTime.Now;
UserBookDataAccess.BookUserUpdateReadOrWant(userBooks[0]);
DisplayAlert("Read Book", "You added this book to Read List", "Ok");
}
else
{
DisplayAlert("Warning", "You already add this book in your Want List", "Ok");
}
}
else
{
if (button.Text == "Want")
{
userBooks[0].ReadWant = ReadWantEnum.Want;
userBooks[0].DateTime = DateTime.Now;
UserBookDataAccess.BookUserUpdateReadOrWant(userBooks[0]);
DisplayAlert("Want Book", "You added this book to Want List", "Ok");
}
else
{
DisplayAlert("Warning", "You already add this book in your Read List", "Ok");
}
}
}
else
{
UserBook userBook = new UserBook {
BookName = Bookname.Text,
Email = App.UserEmail,
DateTime = DateTime.Now
};
if (button.Text == "Want")
{
DisplayAlert("Want Book", "You added this book to Want List", "Ok");
userBook.ReadWant = ReadWantEnum.Want;
}
else
{
DisplayAlert("Read Book", "You added this book to Read List", "Ok");
userBook.ReadWant = ReadWantEnum.Read;
}
UserBookDataAccess.UserInsert(userBook);
}
}
protected void Page_Load(object sender, EventArgs e)
{
rptBooks.ItemCommand += new RepeaterCommandEventHandler(rptBooks_ItemCommand);
rptBooks.ItemDataBound += new RepeaterItemEventHandler(rptBooks_ItemDataBound);
ddlGenre.SelectedIndexChanged += new EventHandler(ddlGenre_SelectedIndexChanged);
if (!Page.IsPostBack)
{
GetGenreData();
if (Request.QueryString["Action"] == "edit")
{
Response.Redirect("Upload.aspx");
}
else if (Request.QueryString["Action"] == "add")
{
User user = (User)Session["User"];
UserBook userb = new UserBook();
Boolean found = false;
foreach (UserBook ub in user.UserBooks.List)
{
if (ub.BookID == new Guid(Request.QueryString["BookID"]))
{
found = true;
Page.ClientScript.RegisterStartupScript(this.GetType(), "CallMyFunction", "BookFound()", true);
break;
}
}
if (found == false)
{
userb.BookID = new Guid(Request.QueryString["BookID"]);
userb.UserID = user.ID;
user.UserBooks.List.Add(userb);
user.Save();
GetBookType();
}
}
}
else
{
if (hidSourceID.Value == string.Empty)
{
GetBookType();
}
}
}
public Book Save(Database db, Guid userID)
{
_UserID = userID;
Boolean result = true;
if (base.IsNew == true && IsSavable() == true)
{
result = Insert(db);
UserBook ub = new UserBook();
ub.UserID = userID;
_UserBooks = new UserBookList();
_UserBooks.List.Add(ub);
}
else if (base.Deleted == true)
{
result = Delete(db);
}
else if (base.IsNew == false && IsSavable() == true)
{
result = Update(db);
}
base.IsDirty = false;
base.IsNew = false;
if (result == true && _UserBooks != null && _UserBooks.IsSavable() == true)
{
result = _UserBooks.Save(db, userID, base.ID);
}
return this;
}
