// edit book and stock by using view model
public async Task <object> EditByVM(int id, BookEditViewModel model)
{
var book = _db.Books.Find(id);
book.BookName = model.BookName;
book.CategoryId = model.CategoryId;
book.PublisherId = model.PublisherId;
book.AuthorId = model.AuthorId;
book.Language = model.Language;
book.ImageUrl = model.ImageUrl;
book.NumberOfPage = model.NumberOfPage;
book.Descriptions = model.Descriptions;
book.Edition = model.Edition;
book.ISBN = model.ISBN;
// book.TranslatorId = model.TranslatorId;
book.CostPrice = model.CostPrice;
book.SellingPrice = model.SellingPrice;
await _db.SaveChangesAsync();
var stockId = (from s in _db.Stocks
where s.BookId == id
select s.StockId).SingleOrDefault();
var stock = _db.Stocks.Find(stockId);
stock.ReorderLevel = model.ReorderLevel;
await _db.SaveChangesAsync();
return(model);
}
public Book(BookEditViewModel bookViewModel)
{
BookId = bookViewModel.BookId;
Title = bookViewModel.Title;
Genre = bookViewModel.Genre;
AuthorId = bookViewModel.AuthorId;
}
public ActionResult Edit(BookEditViewModel viewModel)
{
try
{
if (!ModelState.IsValid)
{
throw new ModelNotValidException("Podaci nisu ispravno uneseni");
}
_repository.UpdateBook(viewModel);
TempData["InfoMsg"] = "Knjiga uspješno ažurirana";
}
catch (Exception e)
{
if (e is ModelNotValidException)
{
TempData["ErrorMsg"] = e.Message;
}
else
{
TempData["ErrorMsg"] = "Pogreška prilikom uređivanja knjige";
}
viewModel.AuthorsSelectList = _repository.GetAuthorsSelectList();
return(View(viewModel));
}
return(RedirectToAction("Details", new { id = viewModel.Id }));
}
public ActionResult Add()
{
var model = new BookEditViewModel();
SetBookDropdownOptions(model);
return(View(model));
}
public IActionResult Edit(BookEditViewModel model)
{
var bookRepo = new BookRepository();
// var model = new BookEditModel();
if (ModelState.IsValid)
{
var editedBook = new Book();
editedBook.Id = model.Id;
editedBook.Title = model.Book.Title;
editedBook.Genre = model.Book.Genre;
editedBook.Author = model.Book.Author;
editedBook.Location = model.Book.Location;
editedBook.YearPublished = model.Book.YearPublished;
editedBook.Type = model.Book.Type;
bookRepo.UpdateBookInfo(editedBook);
//this doesn't work
return(View("home/details/{editedBook.type}/{editedBook.id}"));
}
else
{
return(View());
}
}
public async Task <IActionResult> Edit(long id, [Bind("Id,CoverImage,Title,Summary,ReleaseDate,CategoryId,PublisherId,AuthorId,LanguageId,NarratorId,AudioId,IsActive")] BookEditViewModel viewModel)
{
if (id != viewModel.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
Book book = _mapper.Map <Book>(viewModel);
if (viewModel.CoverImageFile != null)
{
_fileUpload.DeleteFile(viewModel.ExistingCoverImage, uploadImagePath);
var result = _fileUpload.SaveFile(viewModel.CoverImageFile, uploadImagePath);
book.CoverImage = result.UniqueFileName;
}
_context.Update(book);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!BookExists(viewModel.Id))
{
return(NotFound());
}
else
{
throw;
}
}
//return RedirectToAction(nameof(Index));
}
var authors = _context.Authors.Select(s =>
new
{
Id = s.Id,
FullName = string.Format("{0} {1}", s.FirstName, s.LastName)
});
var narrators = _context.Narrators.Select(s =>
new
{
Id = s.Id,
FullName = string.Format("{0} {1}", s.FirstName, s.LastName)
});
ViewData["AudioId"] = new SelectList(_context.AudioFiles, "Id", "Name");
ViewData["AuthorId"] = new SelectList(authors, "Id", "FullName");
ViewData["CategoryId"] = new SelectList(_context.Categories, "Id", "Name");
ViewData["LanguageId"] = new SelectList(_context.Languages, "Id", "Name");
ViewData["NarratorId"] = new SelectList(narrators, "Id", "FullName");
ViewData["PublisherId"] = new SelectList(_context.Publishers, "Id", "Name");
return(PartialView("_EditPartial", viewModel));
}
public BookEditViewModel GetBookEditViewModel(BookItem book, ApplicationDbContext db)
{
BookEditViewModel bookView = new BookEditViewModel();
var item = GetBookViewModel(book, db);
bookView.BookItemViewModel = item;
foreach (var file in book.Attachments)
{
switch (file.FileType)
{
case FileType.Cover:
bookView.Cover = file;
break;
case FileType.TableOfContents:
bookView.Table = file;
break;
case FileType.Attachment:
bookView.OldFiles.Add(file);
break;
}
}
return(bookView);
}
public IActionResult Create(BookEditViewModel bookVM)
{
if (!Admin.logged)
{
return(RedirectToAction("Login", "Admin", 0));
}
if (!ModelState.IsValid)
{
bookVM.Authors = _authorRepository.GetAll();
return(View(bookVM));
}
string cv = bookVM.Book.Cover;
cv.Replace('\\', '/');
try
{
Console.WriteLine($"cover ===={cv}");
System.IO.File.Copy(cv, "C:/Users/Dagi/source/repos/LibraryManagement/wwwroot/images/" + bookVM.Book.BookId + "QQ" + bookVM.Book.AuthorId + ".jpg", true);
bookVM.Book.Cover = "images/" + bookVM.Book.BookId + "QQ" + bookVM.Book.AuthorId + ".jpg";
}
catch
{
}
_repository.Create(bookVM.Book);
return(RedirectToAction("List"));
}
public ActionResult Save(Book book)
{
if (ModelState.IsValid)
{
var bookInDB = _context.Book.SingleOrDefault(s => s.Id == book.Id);
if (bookInDB == null)
{
return(RedirectToAction("Index", "Books"));
}
bookInDB.Name = book.Name;
bookInDB.GenreId = book.GenreId;
_context.SaveChanges();
return(RedirectToAction("Index", "Books"));
}
else
{
var bookRecord = _context.Book.SingleOrDefault(b => b.Id == book.Id);
var genres = _context.Genre.ToList();
var viewModel = new BookEditViewModel()
{
Book = bookRecord,
genres = genres
};
return(View("Edit", viewModel));
}
}
public void EditViewModelValidationErrorRepopulatesAuthorsDropdown()
{
//Arrange
var repository = Mock.Create <IRepository>();
int bookId = 1;
int authorId = 3;
string errorMessage = "The minimal length for the title is 3";
var book = new BookEditViewModel()
{
AuthorId = AuthorHelper.RobertMartin(authorId).AuthorId,
BookId = BookHelper.CleanCode(bookId, authorId).BookId,
Title = "12", //Too short, min is 3 (defined in the view model)
Genre = BookHelper.CleanCode(bookId, authorId).Genre,
};
Mock.Arrange(() => repository.Save((Book)Arg.AnyObject)).OccursNever();
var authorsList = new List <Author>()
{
AuthorHelper.RobertMartin(1), AuthorHelper.JRRTolkien(authorId)
};
Mock.Arrange(() => repository.GetAllAuthors()).Returns(authorsList).OccursOnce();
//Act
var controller = new HomeController(repository);
controller.ModelState.AddModelError("Title", errorMessage); //add the view model validation error
controller.ControllerContext = Mock.Create <ControllerContext>(); //needed by TryValidateModel(entity)
var result = controller.Edit(book) as ViewResult;
//Assert
StandardAssertsForEditErrors(controller, result, book, errorMessage);
Mock.Assert(repository);
}
public void EditDBExceptionRepopulatesAuthorsDropdown()
{
//Arrange
var repository = Mock.Create <IRepository>();
int bookId = 1;
int authorId = 1;
var exceptionMessage = "test exception with message";
var book = new BookEditViewModel()
{
AuthorId = AuthorHelper.RobertMartin(authorId).AuthorId,
BookId = BookHelper.CleanCode(bookId, authorId).BookId,
Title = BookHelper.CleanCode(bookId, authorId).Title,
Genre = BookHelper.CleanCode(bookId, authorId).Genre,
};
Mock.Arrange(() => repository.Save((Book)Arg.AnyObject)).Throws(new Exception(exceptionMessage)).OccursOnce();
var authorsList = new List <Author>()
{
AuthorHelper.RobertMartin(1), AuthorHelper.JRRTolkien(authorId)
};
Mock.Arrange(() => repository.GetAllAuthors()).Returns(authorsList).OccursOnce();
//Act
var controller = new HomeController(repository);
controller.ControllerContext = Mock.Create <ControllerContext>(); //needed by TryValidateModel(entity)
var result = controller.Edit(book) as ViewResult;
//Assert
StandardAssertsForEditErrors(controller, result, book, exceptionMessage);
Mock.Assert(repository);
}
public void EditFormSubmitReturnsToIndex()
{
//Arrange
var repository = Mock.Create <IRepository>();
var submittedBookViewModel = new BookEditViewModel()
{
BookId = 2,
AuthorId = 1,
Genre = BookHelper.CleanCode().Genre,
Title = BookHelper.CleanCode().Title,
Authors = null //after post submit this value is null
};
Mock.Arrange(() => repository.Save((Book)Arg.AnyObject)).OccursOnce();
//Act
var controller = new HomeController(repository);
controller.ControllerContext = Mock.Create <ControllerContext>(); //needed by TryValidateModel(entity)
var result = controller.Edit(submittedBookViewModel) as RedirectToRouteResult;
//Assert
Assert.AreEqual("Index", result.RouteValues["action"]);
Assert.AreEqual("Book edited successfully", controller.TempData["Message"]);
Mock.Assert(repository);
}
public async Task <IActionResult> Edit(int id, BookEditViewModel viewModel)
{
if (id != viewModel.Book.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
var user = await _userManager.GetUserAsync(HttpContext.User);
_context.Update(viewModel.Book);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!BookExists(viewModel.Book.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(viewModel));
}
public IActionResult Detail([FromRoute] int id)
{
BookEditViewModel model;
var selectedBook = _bookService.GetBookById(id);
if (selectedBook == null)
{
model = new BookEditViewModel
{
Id = 0,
Title = "",
CreationDate = DateTime.Now,
Genre = "",
GenreId = 0
};
}
else
{
model = ConvertBookEdit(selectedBook);
}
model.Genres = _bookService.GetAllGenres().Select(x => new SelectListItem {
Text = x.Name,
Value = x.Id.ToString()
}).ToList();
model.Authors = _bookService.GetAllAuthors().Select(x => new SelectListItem
{
Text = x.FullName,
Value = x.Id.ToString()
}).ToList();
return(View(model));
}
public async Task <IActionResult> Edit(string id = null)
{
var model = new BookEditViewModel();
if (id == null)
{
return(View(model));
}
var book = await _BookService.GetById(new Guid(id));
model.Id = id;
model.Titel = book.Titel;
model.Subtitel = book.Subtitel;
model.Isbn = book.Isbn;
model.PublisherName = book.Publisher?.Name;
model.AuthorName = book.GetAuthorString();
model.Series = book.Series;
model.Seriesnumber = book.Seriesnumber;
//model.Genre = book.Genre;
model.Ebook = book.Ebook;
model.Lent = book.Lent;
model.Edit = true;
return(View(model));
}
public IActionResult Edit(BookEditViewModel model)
{
if (ModelState.IsValid)
{
Book newBook = _booksRepository.GetBook(model.Id);
newBook.Title = model.Title;
newBook.Author = model.Author;
newBook.Year = model.Year;
newBook.ISBN = model.ISBN;
newBook.Location = model.Location;
newBook.NumberOfCopies = model.NumberOfCopies;
if (model.Image != null)
{
if (model.ExistingImagePath != null)
{
string filePath = Path.Combine(_hostingEnvironment.WebRootPath, "images", model.ExistingImagePath);
System.IO.File.Delete(filePath);
}
newBook.ImageUrl = ProccessUpoadedFile(model);
}
_booksRepository.Update(newBook);
return(RedirectToAction("index"));
}
return(View());
}
// GET: Books/Create
public IActionResult Create()
{
BookEditViewModel bookEditViewModel = new BookEditViewModel(_context);
bookEditViewModel.Book = new Book();
return(View(bookEditViewModel));
}
public async Task <IActionResult> Edit([Bind(include: "Book")]
BookEditViewModel bookBind)
{
if (ModelState.IsValid)
{
var bookEntity = await _bookService.GetBookById(bookBind.Book.Id, true);
if (bookEntity == null)
{
return(NotFound());
}
_mapper.Map(bookBind.Book, bookEntity);
if (await _bookService.SaveBook(bookEntity) < 1)
{
ModelState.AddModelError("", "Unable to save changes. " +
"Try again, and if the problem persists, " +
"see your system administrator.");
_logger.LogError($"Unable to Update the book: {StringHelper.PrintObjectProps(bookBind.Book)}");
return(View(bookBind));
}
}
return(RedirectToAction(nameof(Index)));
}
private async Task Upsert(int?id)
{
var book = new BookViewModel();
if (id != null)
{
var entity = await @Service.Books.GetAsync(id.Value);
if (entity != null)
{
book.Id = entity.Id;
book.Title = entity.Title;
book.ISBN = entity.ISBN;
book.Price = entity.Price;
book.PublisherId = entity.PublisherId.ToString();
}
}
editVM = new BookEditViewModel
{
Book = book,
Publishers = publisherOptions
};
showEditDialog = true;
}
public ActionResult Edit(BookEditViewModel bookViewModel)
{
if (!ModelState.IsValid)
{
//ModelState for BookEditViewModel is invalid, for example, Title.length < 3
bookViewModel.Authors = PopulateAuthorsDropdown(bookViewModel.AuthorId);
return(View(bookViewModel));
}
var bookEntity = new Book(bookViewModel);
if (!TryValidateModel(bookEntity))
{
//ModelState for Book Entity is invalid, for example, Title.length < 4
bookViewModel.Authors = PopulateAuthorsDropdown(bookViewModel.AuthorId);
return(View(bookViewModel));
}
try
{
repository.Save(bookEntity);
TempData["Message"] = "Book edited successfully";
return(RedirectToAction("Index"));
}
catch (Exception ex)
{
ModelState.AddModelError("", ex.Message);
bookViewModel.Authors = PopulateAuthorsDropdown(bookViewModel.AuthorId);
return(View(bookViewModel));
}
}
public async Task <IActionResult> Edit(int id, [Bind("BookId,Title,Author,ISBN,CheckedOut,LibraryId")] Book book)
{
if (id != book.BookId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(book);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!BookExists(book.BookId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
BookEditViewModel bookEditViewModel = new BookEditViewModel(_context);
bookEditViewModel.Book = book;
return(View(bookEditViewModel));
}
public ActionResult Create(BookEditViewModel viewModel)
{
try
{
using (var wrapper = new SessionWrapper())
{
using (ITransaction transaction = wrapper.Session.BeginTransaction())
{
long id;
foreach (var idString in viewModel.SelectedAuthors)
{
if (long.TryParse(idString, out id))
{
viewModel.BookItem.Authors.Add(wrapper.Session.Get <Author>(id));
}
}
wrapper.Session.Save(viewModel.BookItem);
transaction.Commit();
}
}
return(RedirectToAction("Index"));
}
catch (Exception exception)
{
return(RedirectToAction("EditBook", viewModel));
}
}
public ActionResult Edit(BookEditViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
BookRepository repository = new BookRepository();
Book book = new Book();
book.Id = model.Id;
book.ImgURL = model.imgURL;
book.NumberISBN = model.numberISBN;
book.Title = model.title;
book.Author = model.author;
book.PublishingHouse = model.publishingHouse;
if (book.ReleaseDate != model.releaseDate)
{
book.ReleaseDate = model.releaseDate;
}
else
{
book.ReleaseDate = book.ReleaseDate;
}
book.Availability = model.availability;
repository.Save(book);
return(RedirectToAction("Index", "Books"));
}
public ActionResult Edit(BookEditViewModel viewModel)
{
using (var wrapper = new SessionWrapper())
{
long id;
foreach (var idString in viewModel.SelectedAuthors)
{
if (long.TryParse(idString, out id))
{
viewModel.BookItem.Authors.Add(wrapper.Session.Get <Author>(id));
}
}
var bookToUpdate = wrapper.Session.Get <Book>(viewModel.BookItem.Id);
bookToUpdate.Name = viewModel.BookItem.Name;
bookToUpdate.PublicationDate = viewModel.BookItem.PublicationDate;
bookToUpdate.ISBN = viewModel.BookItem.ISBN;
bookToUpdate.Authors = viewModel.BookItem.Authors;
using (ITransaction transaction = wrapper.Session.BeginTransaction())
{
wrapper.Session.Save(bookToUpdate);
transaction.Commit();
}
}
return(RedirectToAction("Index"));
}
public IActionResult Edit(BookEditViewModel model)
{
if (ModelState.IsValid)
{
Book book = _bookRepository.GetBook(model.Id);
book.Title = model.Title;
book.Author = model.Author;
book.Category = model.Category;
book.CategoryId = model.CategoryId;
book.ISBN = model.ISBN;
book.Price = model.Price;
if (model.Photo != null)
{
if (model.ExixtingPhotoPath != null)
{
string filePath = Path.Combine(iHostingEnvironment.WebRootPath, "images", model.ExixtingPhotoPath);
System.IO.File.Delete(filePath);
}
;
book.PhotoPath = ProcessUploadedFile(model);
}
_bookRepository.Update(book);
return(RedirectToAction("index"));
}
return(View());
}
public async Task <IActionResult> Edit(BookEditViewModel viewModel)
{
if (!ModelState.IsValid)
{
return(View(viewModel));
}
var model = await _context.Books
.Include(x => x.BookAuthors)
.FirstOrDefaultAsync(x => x.Id == viewModel.Id);
if (model != null)
{
model.Title = viewModel.Title;
model.BookAuthors.Clear();
model.BookAuthors.AddRange(viewModel.AuthorsIds
.Select(authorId => new BookAuthor {
AuthorId = authorId, BookId = viewModel.Id
}));
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
else
{
return(NotFound());
}
}
public IActionResult Edit(BookEditViewModel model)
{
if (ModelState.IsValid)
{
Book book = _bookRepository.GetBook(model.Id);
book.Title = model.Title;
book.Author = model.Author;
book.ISBN = model.ISBN;
book.Category = model.Category;
book.Quantity = model.Quantity;
if (model.Image != null)
{
if (!string.IsNullOrWhiteSpace(model.ExistingImagePath))
{
string existingPath = Path.Combine(_hostingEnvironment.WebRootPath, "images/books", model.ExistingImagePath);
System.IO.File.Delete(existingPath);
}
book.ImageFileName = ProcessUploadFile(model);
}
_bookRepository.Update(book);
_logger.LogInformation($"Updated book(id: {book.Id})");
return(RedirectToAction("Index"));
}
return(View());
}
public IActionResult Edit(int?id)
{
var model = new BookEditViewModel();
if (id.HasValue)
{
model.Book = bookService.GetBookById(id.Value);
if (model.Book == null)
{
return(View("NotFound"));
}
}
else
{
model.Book = new Book();
}
model.SelectAuthor = authorService.GetAuthors().Select(a => new SelectListItem
{
Text = a.Name,
Value = a.Id.ToString()
});
model.SelectPublisher = publisherService.GetPublishers().Select(p => new SelectListItem
{
Text = p.Name,
Value = p.Id.ToString()
});
return(View(model));
}
// GET: BookItems/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
BookEditViewModel bookItem = vt.GetBookEditViewModel(db.BookItems.Include(x => x.Category).Single(x => x.BookItemID == id), db);
if (bookItem == null)
{
return(HttpNotFound());
}
if (Request.UrlReferrer != null)
{
bookItem.BookItemViewModel.PreviousPage = Request.UrlReferrer.ToString();
}
else
{
bookItem.BookItemViewModel.PreviousPage = Request.Url.GetLeftPart(UriPartial.Authority);
}
ViewBag.CategoryID = new SelectList(db.Categories, "CategoryID", "Name");
ViewBag.Authors = new SelectList(vt.GetAuthorsFromDb(db), "Value", "Text");
ViewBag.Labels = new SelectList(db.Labels, "LabelID", "Name");
ViewBag.Init = true;
return(View(bookItem));
}
public ActionResult Edit(Guid?id)
{
Book book = this.bookServices.GetById(id);
BookEditViewModel viewModel = new BookEditViewModel(book);
return(View(viewModel));
}
