public async Task <IActionResult> Edit(int?id)
{
if (id == null)
{
return(NotFound());
}
var book = await _context.Books.FindAsync(id);
//string imageFileWithGuid = book.PhotoPath;
//var filname = (imageFileWithGuid != null) ? imageFileWithGuid.Substring(imageFileWithGuid.IndexOf("_") + 1);
//We pass down the book to be updated
BookCreateViewModel model = new BookCreateViewModel()
{
Name = book.Name,
Author = book.Author,
Description = book.Description,
Price = book.Price,
GenreId = book.GenreId,
Genres = book.Genres,
Alt = book.Alt,
PhotoPath = book.PhotoPath
};
if (book == null)
{
return(NotFound());
}
ViewData["GenreId"] = new SelectList(_context.Genre, "GenreId", "GenreName", book.GenreId);
return(View(model));
}
public IActionResult CreateBook(BookCreateViewModel model)
{
if (ModelState.IsValid)
{
var book = new Book()
{
Name = model.Name,
Price = model.Price,
Author = model.Author,
Depscrip = model.Depscrip,
GenreId = model.GenreId,
Remain = model.Remain,
};
var fileName = string.Empty;
if (model.AvatarPath != null)
{
string uploadFolder = Path.Combine(webHostEnvironment.WebRootPath, "images");
fileName = $"{Guid.NewGuid()}_ {model.AvatarPath.FileName}";
var filePath = Path.Combine(uploadFolder, fileName);
using (var fs = new FileStream(filePath, FileMode.Create))
{
model.AvatarPath.CopyTo(fs);
};
}
book.AvatarPath = fileName;
var newBook = bookRepository.Create(book);
return(RedirectToAction("BookManagement", new { id = newBook.Id }));
}
return(View());
}
public ActionResult Create(BookCreateViewModel viewModel)
{
viewModel.Genres = this.genreService.GetAll()
.Select(x => new SelectListItem
{
Text = x.Name,
Value = x.Id.ToString()
}).ToList();
if (!ModelState.IsValid)
{
return(View(viewModel));
}
var fileName = Path.GetFileName(viewModel.Image.FileName);
var ext = Path.GetExtension(viewModel.Image.FileName);
string name = Path.GetFileNameWithoutExtension(fileName);
string myfile = name + "_" + DateTime.Now.ToFileTimeUtc() + ext;
var path = Path.Combine(HttpContext.Server.MapPath("~/Img"), myfile);
this.bookService.Add(new Models.Book
{
CreationDate = new DateTime(viewModel.CreationYear, 1, 1),
GenreId = viewModel.GenreId,
ImageUrl = "Img/" + myfile,
Name = viewModel.Name,
PageCount = viewModel.PageCount
});
viewModel.Image.SaveAs(path);
return(RedirectToAction("Index"));
}
public ActionResult Create(BookCreateViewModel bookVM)
{
User author = usersService.FindSingle(this.User.Identity.Name);
Book book = new Book()
{
Id = Guid.NewGuid(),
Title = bookVM.Title,
CatalogueNumber = bookVM.CatalogueNumber,
Resume = bookVM.Resume,
isDeleted = false,
DeletedOn = null,
CreatedOn = DateTime.Now,
ModifiedOn = DateTime.Now,
Author = author
};
try
{
var task = this.booksService.Add(book);
}
catch
{
ModelState.AddModelError("", "Unable to add the Book");
return(View("_CreateBookPartial", bookVM));
}
return(Content("success"));
}
public async Task AddBook(BookCreateViewModel book)
{
var bookModel = _bookMapping.MapToModelCreate(book);
_context.Add(bookModel);
await _context.SaveChangesAsync();
}
public ActionResult Create(BookCreateViewModel viewModel)
{
int id = 0;
try
{
if (!ModelState.IsValid)
{
throw new ModelNotValidException("Podaci nisu ispravno uneseni");
}
_repository.AddBook(viewModel);
id = _repository.GetLastBookId();
TempData["InfoMsg"] = "Nova knjiga uspješno kreirana";
}
catch (Exception e)
{
if (e is ModelNotValidException)
{
TempData["ErrorMsg"] = e.Message;
}
else
{
TempData["ErrorMsg"] = "Pogreška prilikom kreiranja nove knjige";
}
viewModel.AuthorsSelectList = _repository.GetAuthorsSelectList();
return(View(viewModel));
}
return(RedirectToAction("Details", new { @id = id }));
}
public IActionResult Create(int publisherId)
{
BookCreateViewModel model = new BookCreateViewModel();
model.LoadModelData(_unitOfWork, publisherId);
return(View(model));
}
public ActionResult Create(BookCreateViewModel model)
{
Guard.WhenArgument(model, "model").IsNull().Throw();
if (!this.ModelState.IsValid)
{
return(this.View(model));
}
var book = new Book
{
Title = model.Title,
Author = model.Author,
AuthorId = model.Author.Id,
Description = model.Description,
UserId = this.User.Identity.GetUserId()
};
try
{
book.Title = Sanitizer.GetSafeHtmlFragment(model.Title);
book.Description = Sanitizer.GetSafeHtmlFragment(model.Description);
this.bookServices.AddBook(book);
}
catch (Exception)
{
this.TempData["Notification"] = "Exception.";
return(View(model));
}
this.TempData["Notification"] = "Succesfully created a book!";
return(Redirect("/"));
}
// GET: Books/Create
public IActionResult Create()
{
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");
BookCreateViewModel viewModel = new BookCreateViewModel();
return(PartialView("_CreatePartial", viewModel));
}
/// <inheritdoc />
Task IBookApiService.PostAsync(BookCreateViewModel book, string authorization)
{
var arguments = new object[] { book, authorization };
var func = requestBuilder.BuildRestResultFuncForMethod("PostAsync", new Type[] { typeof(BookCreateViewModel), typeof(string) });
return((Task)func(Client, arguments));
}
public async Task <IActionResult> Edit(int id, [Bind("BookId,Title,Author,ISBN,LibraryId,PatronId")] 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)));
}
BookCreateViewModel bookCreate = new BookCreateViewModel(_context);
bookCreate.Book = book;
//ViewData["LibraryId"] = new SelectList(_context.Library, "LibraryId", "LibraryId", book.LibraryId);
return(View(book));
}
public async Task <ActionResult> Create(BookCreateViewModel model)
{
try
{
if (!ModelState.IsValid)
{
return(View(model));
}
var user = await UserManager.FindByIdAsync(model.UserId);
var category = _unitOfWork.CategoryRepository.Get(x => x.Id == model.CategoryId);
var newBook = new Book()
{
Name = model.Name,
ReleaseYear = model.ReleaseYear,
Author = model.Author,
Description = model.Description,
Draft = model.Draft,
User = user,
Category = category
};
_unitOfWork.BookRepository.Add(newBook);
if (_unitOfWork.Complete() > 0)
{
return(RedirectToAction(nameof(Index)));
}
return(View(model));
}
catch
{
return(View(model));
}
}
public async Task <IActionResult> Create(BookCreateViewModel viewModel)
{
// NOTE: Ignore any ModelState errors for a particular property by "removing" it's key
// Since we are using a ViewModel, the ModelState Keys
// MUST include the ViewModels' Book property
ModelState.Remove("Book.Author");
ModelState.Remove("Book.Owner");
ModelState.Remove("Book.OwnerId");
if (ModelState.IsValid)
{
var book = viewModel.Book;
var currentUser = await _userManager.GetUserAsync(HttpContext.User);
book.OwnerId = currentUser.Id;
_context.Add(book);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
viewModel.AvailableAuthors = await _context.Author.ToListAsync();
return(View(viewModel));
}
// GET: Books/Create
public IActionResult Create()
{
BookCreateViewModel bookCreate = new BookCreateViewModel(_context);
//ViewData["LibraryId"] = new SelectList(_context.Library, "LibraryId", "Name");
return(View(bookCreate));
}
public async Task <ActionResult> Create(BookCreateViewModel BookCreateViewModel)
{
if (!ModelState.IsValid)
{
ModelState.AddModelError(string.Empty, "Model is not valid");
return(View());
}
try
{
var newModel = await _bookService.AddAsync(new Book
{
Author = _htmlEncoder.Encode(BookCreateViewModel.Author),
Title = BookCreateViewModel.Title,
CoverUrl = BookCreateViewModel.CoverUrl,
Price = BookCreateViewModel.Price,
ReleaseDate = BookCreateViewModel.ReleaseDate
});
return(RedirectToAction(nameof(Details), new { id = newModel.Id }));
}
catch
{
return(View(BookCreateViewModel));
}
}
public async Task <IActionResult> Edit(int id, BookCreateViewModel viewModel)
{
if (id != viewModel.Book.Id)
{
return(NotFound());
}
ModelState.Remove("Book.ApplicationUserId");
if (ModelState.IsValid)
{
try
{
var user = await _userManager.GetUserAsync(HttpContext.User);
viewModel.Book.ApplicationUserId = user.Id;
_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.Book));
}
public ActionResult Create()
{
BookCreateViewModel Model = new BookCreateViewModel();
Model.ListaKategorija = ctx.KategorijaKnjige.ToList();
return(View(Model));
}
// GET: Books/Create
public async Task <IActionResult> Create()
{
var viewModel = new BookCreateViewModel
{
AvailableAuthors = await _context.Author.ToListAsync(),
};
return(View(viewModel));
}
public IActionResult Create()
{
BookCreateViewModel bookCreateViewModel = new BookCreateViewModel()
{
Authors = _iAuthorRepository.GetAll()
};
return(View(bookCreateViewModel));
}
public IActionResult Create(BookCreateViewModel book)
{
if (ModelState.IsValid)
{
_adminService.CreateBook(book);
return(RedirectToAction("Index"));
}
return(View());
}
// GET: Books/Create
public IActionResult Create()
{
var model = new BookCreateViewModel();
model.GenreList = new SelectList(_context.Genres.Select(b => new { b.GenreId, b.Name }).ToList(), "GenreId", "Name");
model.DeweyList = new SelectList(_context.Deweys.Select(b => new { b.DeweyID, b.Name }).ToList(), "DeweyID", "Name");
return(View(model));
}
public IActionResult Update(int id)
{
BookCreateViewModel bookCreateViewModel = new BookCreateViewModel()
{
Authors = _iAuthorRepository.GetAll(),
Book = _iBookRepository.GetById(id)
};
return(View(bookCreateViewModel));
}
public ActionResult Create()
{
var authors = _context.Authors.ToList();
var model = new BookCreateViewModel()
{
Authors = new SelectList(authors, "Id", "LastName")
};
return(View(model));
}
public async Task <IActionResult> Create(BookCreateViewModel viewModel)
{
if (!await _sessionService.IsAuthentificateAsync())
{
return(RedirectToAction("Login", "Library"));
}
if (!ModelState.IsValid)
{
return(View(viewModel));
}
// verify the barcode
if (!string.IsNullOrWhiteSpace(viewModel.Barcode))
{
var barcodeExist = _db.Books.Any(x => x.Barcode.ToLower() == viewModel.Barcode && x.LibraryId == _sessionService.GetCurrentLibraryId());
if (barcodeExist)
{
ModelState.AddModelError(nameof(BookCreateViewModel.Barcode), "This barcode is already assigned to another book");
return(View(viewModel));
}
}
var book = _mapper.Map <Book>(viewModel);
// Add tags
if (!string.IsNullOrWhiteSpace(viewModel.BookTags))
{
book.Tags = viewModel.BookTags.Split(";").Select(x => new BookTag
{
Name = x
}).ToList();
}
// Add images
if (viewModel.Files != null && viewModel.Files.Any())
{
book.Images = viewModel.Files.Select(file =>
{
string savePath = _fileService.SaveFile(file);
return(new BookPicture
{
FullPath = savePath,
Size = file.Length
});
}).ToList();
}
book.LibraryId = _sessionService.GetCurrentLibraryId();
_db.Add(book);
await _db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
public void Throw_ArgumentNullException_When_Passed_ViewModel_Is_Null()
{
// Arrange
BookCreateViewModel viewModelNull = null;
Mock <IBookServices> bookServiceMock = new Mock <IBookServices>();
BookController sut = new BookController(bookServiceMock.Object);
// Act & Assert
Assert.Throws <ArgumentNullException>(() => sut.Create(viewModelNull));
}
public IActionResult Create(BookCreateViewModel bookCreateViewModel)
{
if (!ModelState.IsValid || bookCreateViewModel.Book.Author.Id <= 0)
{
return(View(bookCreateViewModel));
}
_iBookRepository.Create(bookCreateViewModel.Book);
return(RedirectToAction("List"));
}
public IActionResult Update(BookCreateViewModel bookCreateViewModel)
{
if (!ModelState.IsValid)
{
return(View(bookCreateViewModel));
}
_iBookRepository.Update(bookCreateViewModel.Book);
return(RedirectToAction("List"));
}
public Book MapToModelCreate(BookCreateViewModel viewbook)
{
Book model = new Book()
{
Title = viewbook.Title,
Price = viewbook.Price,
CreationDate = viewbook.CreationDate
};
return(model);
}
// GET: Books/Create
public async Task <IActionResult> Create()
{
var user = await _userManager.GetUserAsync(HttpContext.User);
var viewModel = new BookCreateViewModel()
{
Authors = await _context.Authors.Where(a => a.ApplicationUserId == user.Id).ToListAsync()
};
return(View(viewModel));
}
// return view for creating new book
public ActionResult ManageCreateBook()
{
BookCreateViewModel viewModel = new BookCreateViewModel();
var authors = this.unitOfWork.Authors.GetAll().OrderBy(a => a.Name).ToList();
var publishers = this.unitOfWork.Publishers.GetAll().OrderBy(p => p.Name).ToList();
viewModel.MultiSelectedAuthors = new MultiSelectList(authors, "Id", "Name");
viewModel.SelectedPublishers = new SelectList(publishers, "Id", "Name");
return(View(viewModel));
}
