public async Task <IActionResult> Edit(Guid id)
{
var book = await _context.Books.Include(it => it.Authors).Include(it => it.Cover).SingleAsync(it => it.Id.Equals(id));
var authors = book.Authors.Select(it => it.AuthorId);
var authorSelectList = _context.Authors.AsNoTracking().Select(it => new SelectListItem
{
Selected = authors.Contains(it.Id),
Value = it.Id.ToString(),
Text = it.Name
});
var cover = _fileUpload.UrlFor(book.Cover?.Path);
var viewModel = new EditBookViewModel
{
Id = book.Id,
Title = book.Title,
Authors = authors,
AuthorSelectList = authorSelectList,
Cover = cover
};
return(View(viewModel));
}
public async Task <ActionResult> Edit(EditBookViewModel e)
{
if (ModelState.IsValid)
{
var imgUrl = UploadImage(e.Img, e.OriginalImgUrl);
if (!String.IsNullOrEmpty(imgUrl))
{
Book book = await db.Books.FindAsync(e.BookID);
if (book == null)
{
return(HttpNotFound());
}
db.Entry(EditBookViewModel.ConvertToBook(e, book, imgUrl)).State = EntityState.Modified;
await db.SaveChangesAsync();
TempData["Msg"] = "alert('Book: " + e.Title + " has been edited successfully!')";
return(RedirectToAction("SellingBook"));
}
else
{
ModelState.AddModelError("", "Please choose either a GIF, JPG or PNG image.");
}
}
return(View(e));
}
public async Task <ActionResult> Edit(int id)
{
if (id == 0)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Book book = await db.Books.Include(b => b.Authors).Include(b => b.Categories).FirstAsync(b => b.Id == id);
if (book == null)
{
return(HttpNotFound());
}
EditBookViewModel model = new EditBookViewModel();
var categories = db.Categories.Select(c => new { Id = c.Id, Name = c.Name }).ToList();
var publishers = db.Publishers.Select(c => new { Id = c.Id, Name = c.Name }).ToList();
var authors = db.Authours.Select(c => new { Id = c.Id, Name = c.FirstName }).ToList();
model.Category = new SelectList(categories, "Id", "Name", book.CategoryId);
model.Categories = new MultiSelectList(categories, "Id", "Name", book.Categories.Select(c => c.Id).ToArray());
model.Authors = new MultiSelectList(authors, "Id", "Name", book.Authors.Select(c => c.Id).ToArray());
model.Publisher = new SelectList(publishers, "Id", "Name", book.PublisherId);
model.Title = book.Title;
model.Age = book.Age;
model.Descriptions = book.Descriptions;
model.CategoryId = book.CategoryId;
model.PublisherId = book.PublisherId;
model.Print = book.Print;
model.PrintDate = book.PrintDate;
return(View(model));
}
public EditBook(int id)
{
InitializeComponent();
var editBookViewModel = new EditBookViewModel(this, id);
BindingContext = editBookViewModel;
}
public IActionResult Create()
{
var book = new EditBookViewModel();
_bookService.AddListItemToBook(book);
return(View(book));
}
public ActionResult Add(HttpPostedFileBase file, EditBookViewModel model)
{
var f = Request.Form;
if (file != null && file.ContentLength > 0)
{
var fileExt = Path.GetExtension(file.FileName);
var filename = Guid.NewGuid() + fileExt;
var path = Path.Combine(Server.MapPath("~/Content/Covers/"), filename);
file.SaveAs(path);
model.Book.CoverFileName = filename;
db.Entry(model.Book).State = EntityState.Added;
db.SaveChanges();
return(RedirectToAction("Index", new { confirmSuccess = true }));
}
else
{
ModelState.AddModelError("", "Nie wskazano pliku.");
var genres = db.Genres.ToArray();
model.Genres = genres;
return(View(model));
}
}
public IActionResult EditBook(int libraryID)
{
EditBookViewModel viewModel = new EditBookViewModel();
viewModel.Book = SearchUtility.GetBookByLibraryID(libraryID);
return(View(viewModel));
}
public void UpdateBook(EditBookViewModel tempNewsPaper)
{
var newsBook = new Book();
Mapper.Map(tempNewsPaper, newsBook);
_bookRepository.Update(newsBook);
}
public async Task <IActionResult> Edit(EditBookViewModel model)
{
var book = await GetAllBooksWithDetails().FirstOrDefaultAsync(b => b.Id == model.Id);
if (book == null)
{
return(NotFound());
}
try
{
if (ModelState.IsValid)
{
book.Title = model.Title;
UpdateGenres(model.SelectedGenres, book);
UpdateAuthors(model.SelectedAuthors, book);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
}
catch (DbUpdateException e)
{
//Log the error (uncomment ex variable name and write a log.)
ModelState.AddModelError("", "Unable to save changes. " +
"Try again, and if the problem persists, " +
"see your system administrator.");
}
return(View(await PopulateEditBookViewModel(book)));
}
public async Task <IActionResult> Create(EditBookViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var book = new Book
{
Title = model.Title,
BookAuthors =
new List <BookAuthor>(model.SelectedAuthors.Select(a => new BookAuthor
{
AuthorId = a, BookId = model.Id
})),
Genres = new List <GenreEntry>(model.SelectedGenres.Select(g => new GenreEntry
{
GenreName = g, BookId = model.Id
}))
};
_context.Add(book);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
public async Task <ActionResult <Libros> > updateBook(int id, [FromBody] EditBookViewModel libro)
{
try
{
if (id != libro.Id)
{
return(BadRequest());
}
Libros libroAActualizar = await librosRepository.getBook(id);
if (libroAActualizar == null)
{
return(NotFound($"El libro con el id {id} no ha sido encontrado"));
}
libroAActualizar.Id = id;
libroAActualizar.Nombre = libro.Nombre;
libroAActualizar.Descripcion = libro.Descripcion;
libroAActualizar.Genero = libro.Genero;
libroAActualizar.Autor = libro.Autor;
var result = await librosRepository.updateBook(libroAActualizar);
return(Ok(result));
}
catch (Exception)
{
return(StatusCode(StatusCodes.Status500InternalServerError, "Error..."));
}
}
public async Task <ActionResult> Create(EditBookViewModel model)
{
var author = bookService.GetAuthor(model.SelectedAuthorId).Result;
await bookService.CreateNewBookWithAuthor(author, model.SelectedBook.Name, model.SelectedBook.PublicationYear);
return(RedirectToAction("Index"));
}
public async Task <IActionResult> Edit(int?id)
{
if (id == null)
{
return(NotFound());
}
var books = await _context.Books.FindAsync(id);
if (books == null)
{
return(NotFound());
}
var model = new EditBookViewModel
{
BookId = books.BookId,
BookName = books.BookName,
BookDescription = books.BookDescription,
Author = books.Author,
Contact = Convert.ToInt32((await _userManager.GetUserAsync(User)).PhoneNumber),
genero = books.genero,
idioma = books.idioma,
EmailCreator = (await _userManager.GetUserAsync(User)).Email,
ExistingPhotoPath = books.PhotoPath
};
return(View(model));
}
public async Task <ActionResult <Libros> > updateBook(int id)
{
try
{
Libros libroAActualizar = await librosRepository.getBook(id);
if (libroAActualizar == null)
{
return(NotFound($"El libro con el id {id} no ha sido encontrado"));
}
EditBookViewModel infoLibro = new EditBookViewModel()
{
Id = libroAActualizar.Id,
Nombre = libroAActualizar.Nombre,
Descripcion = libroAActualizar.Descripcion,
Genero = libroAActualizar.Genero,
Autor = libroAActualizar.Autor
};
return(Ok(infoLibro));
}
catch (Exception)
{
return(StatusCode(StatusCodes.Status500InternalServerError, "Error..."));
}
}
private void Load(Book book = null)
{
InitializeComponent();
vm = new EditBookViewModel(this, book);
this.DataContext = vm;
}
public ActionResult EditBook(EditBookViewModel model)
{
LibraryDal dal = new LibraryDal();
Book newBook = new Book()
{
ISBN = model.book.ISBN,
Title = model.book.Title,
TotalQuantity = model.book.TotalQuantity,
Archived = model.book.Archived
};
if (ModelState.IsValid)
{
if (model.oldISBN != newBook.ISBN)
{
Book newIsbnBook = dal.GetBookByISBN(newBook.ISBN);
if (newIsbnBook != null)
{
model.alreadyExists = true;
return(View(model));
}
dal.UpdateBook(dal.GetBookById(model.bookId), newBook);
return(RedirectToAction("Index"));
}
dal.UpdateBook(dal.GetBookById(model.bookId), newBook);
return(RedirectToAction("Index"));
}
return(View(model));
}
public async Task <IActionResult> Edit(int?id)
{
if (id == null)
{
return(NotFound());
}
var book = await _context.Books.FindAsync(id);
if (book == null)
{
return(NotFound());
}
var editBookVm = new EditBookViewModel
{
Id = book.Id,
Title = book.Title,
AddedByAdmin = book.AddedByAdmin,
BookAuthor = book.BookAuthor,
BookCategory = book.BookCategory,
QuestionsAuthor = book.QuestionsAuthor,
PartOfSchoolProgramAtGrade = book.PartOfSchoolProgramAtGrade,
Publisher = book.Publisher,
Description = book.Description,
IsShortForm = book.IsShortForm,
Isbn1 = book.Isbn1,
Isbn2 = book.Isbn2,
Tags = book.Tags,
Translator = book.Translator,
NumberOfPages = book.NumberOfPages,
YearPublished = book.YearPublished,
Grade = book.Grade,
};
return(View(editBookVm));
}
public async Task UpdateBookAsync(EditBookViewModel tempNewsPaper)
{
var newsBook = new Book();
Mapper.Map(tempNewsPaper, newsBook);
await _bookRepository.UpdateAsync(newsBook);
}
public EditBook(model.Book book)
{
InitializeComponent();
ToggleForm();
this.book = new model.Book(book);
DataContext = new EditBookViewModel(book);
EditBookItemForm.ToggleForm += EditBookItemForm_ToggleForm;;
}
//EditBookViewModel editBookViewModel = new EditBookViewModel();
public EditBook(ref Book book)
{
InitializeComponent();
editBook = new EditBookViewModel(book);
DataContext = editBook;
editBook.Closing += (s, e) => Close();
}
public async Task <ActionResult> DeleteConfirmed(int id)
{
EditBookViewModel book = await bookService.GetBookAsync(id);
await bookService.DeleteAsync(id);
return(RedirectToAction("Index", "Base"));
}
public IActionResult Create(EditBookViewModel editBook)
{
if (!ModelState.IsValid)
{
return(View(editBook));
}
_bookService.Create(editBook);
return(RedirectToAction("Index", "Book"));
}
public ActionResult Add()
{
var addBook = new EditBookViewModel();
var genres = db.Genres.ToArray();
addBook.Genres = genres;
return(View(addBook));
}
public async Task <ApiResponse <EditBookViewModel> > UpdateBook(EditBookViewModel model)
{
return(await HandleApiOperationAsync(async() =>
{
var(errs, responseModel) = await _bookService.UpdateBook(model);
return new ApiResponse <EditBookViewModel>
(data: errs.Any() ? null : responseModel, errors: errs.Any() ? errs.Select(p => p.ErrorMessage).ToArray() : new string[] { });
}).ConfigureAwait(false));
}
public ActionResult EditBook(EditBookViewModel model)
{
var result = _itemService.EditBook(model);
if (!result)
{
return(View());
}
return(RedirectToAction("Index", "Item"));
}
public async Task <ActionResult> Edit(EditBookViewModel book)
{
if (ModelState.IsValid)
{
await bookService.UpdateBookAsync(book);
return(RedirectToAction("Index", "Base"));
}
return(View(book));
}
private void updateBookImage(model.Book book)
{
if (imageName != "")
{
byte[] imageData = File.ReadAllBytes(imageName);
string base64String = Convert.ToBase64String(imageData, 0, imageData.Length);
book.imgSource = base64String;
DataContext = new EditBookViewModel(book);
}
}
public ActionResult Create()
{
var vm = new EditBookViewModel()
{
AvailableAuthors = new SelectList(bookService.GetAuthors().Result, "Id", "Name"),
SelectedBook = new Book()
};
return(PartialView("_CreateBook", vm));
}
public async Task <EditBookViewModel> Get(string id)
{
var model = new EditBookViewModel()
{
Authors = await _authorRepository.GetList(),
Publishings = await _publishingRepository.GetList(),
Book = await _bookRepository.GetByIdAsync(id)
};
return(model);
}
public EditBookViewModel GetBook(int?id)
{
Book tempBook = _bookRepository.FindById(id);
EditBookViewModel book = new EditBookViewModel();
Mapper.Map(tempBook, book);
book.ListGeners = new SelectList(_generRepository.Get(), "Id", "Genre");
return(book);
}
