public ActionResult Create(CreateBookViewModel viewModel)
{
_bookService.Create(new CreateBookDto {
Name = viewModel.Name, Author = viewModel.Author
});
return(View());
}
public IActionResult Create(CreateBookViewModel model)
{
if (ModelState.IsValid)
{
var book = new Book();
foreach (int authorId in model.AuthorsIds)
{
book.Authors.Add(new Author {
Id = authorId
});
}
foreach (int categoryId in model.CategoriesIds)
{
book.Categories.Add(new Category {
Id = categoryId
});
}
_unitOfWork.Articles.AddArticle(book);
_unitOfWork.SaveChanges();
this.SetUserMessage(UserMessageType.Success, _localizer["Success_BookCreated"]);
return(RedirectToAction("Index", "Inventory"));
}
LoadCreateViewBags();
return(View(model));
}
public Book AddBook(CreateBookViewModel book)
{
var newbook = _mapper.Map <CreateBookViewModel, Book>(book);
_books.InsertOneAsync(newbook);
return(newbook);
}
public ActionResult Create(CreateBookViewModel viewModel)
{
if (db.Books.Any(b => b.Isbn == viewModel.Isbn))
{
viewModel.AuthorsCollection = db.Author.ToList();
viewModel.PublishersCollection = db.Publishers.ToList();
viewModel.CategoriesCollection = db.Categories.ToList();
ModelState.AddModelError("Isbn", "Książka o takim isbn istnieje.");
return(View(viewModel));
}
if (ModelState.IsValid)
{
HttpPostedFileBase file = Request.Files["fileImage"];
if (file != null && file.ContentLength > 0)
{
viewModel.Image = System.Guid.NewGuid().ToString() + ".jpg";
file.SaveAs(HttpContext.Server.MapPath("~/Images/") + viewModel.Image);
}
viewModel.Author = db.Author.First(a => a.ID == viewModel.SelectedAuthorID);
viewModel.Publisher = db.Publishers.First(a => a.ID == viewModel.SelectedPublisherID);
viewModel.Categories = new List <Category>();
foreach (var i in viewModel.SelectedCategoryID)
{
viewModel.Categories.Add(db.Categories.Single(a => a.ID == i));
}
db.Books.Add(viewModel.GetBook());
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(viewModel));
}
public async Task OnGetAsync()
{
Book = new CreateBookViewModel();
var authorLookup = await _bookAppService.GetAuthorLookupAsync();
Authors = authorLookup.Items.Select(x => new SelectListItem(x.Name, x.Id.ToString())).ToList();
}
public ActionResult Create(CreateBookViewModel model)
{
Book book = new Book
{
Name = model.Name,
GenreID = model.Genre,
AuthorID = model.Author,
SeriesID = model.Series,
Price = model.Price,
Pages = model.Pages,
ImageName = model.ImageName
};
if (Request.Files.Count > 0)
{
HttpPostedFileBase file = Request.Files[0];
if (file.ContentLength != 0)
{
string imgPath = Server.MapPath(Constants.ImagesDirectory);
string fileName = file.FileName;
string savedFileName = Path.Combine(imgPath, Path.GetFileName(fileName));
file.SaveAs(savedFileName);
book.ImageName = fileName;
}
else
{
book.ImageName = Constants.NoCoverPath;
}
}
bookRepository.Create(book);
return(RedirectToAction("Index"));
}
public void Ensure_Book_Cant_Add_With_UnrelatedKeys()
{
var customerGuid = Guid.NewGuid();
var catGuid = Guid.NewGuid();
_authorRepository.Setup(y => y.GetById(It.IsAny <Guid>()))
.Returns(new Author {
Id = customerGuid, FirstName = "daiusd", LastName = "dshjads"
});
_categoryRepository.Setup(y => y.GetById(It.IsAny <Guid>()))
.Returns(new Category {
Id = catGuid, Title = "E don Pass"
});
var model = new CreateBookViewModel
{
Title = "Latest Book in Town",
AuthorIds = new List <Guid> {
customerGuid
},
CategoryId = catGuid.ToString(),
IsbnCode = "kysf3234",
Published = DateTime.Now.Date
};
var controller = new BookApiController(_bookService.Object);
var response = controller.AddBook(model).Result;
Assert.Equal(StatusCodes.Status500InternalServerError, response.Code);
}
public async Task <IActionResult> Create(CreateBookViewModel model)
{
if (ModelState.IsValid)
{
string uniqueFileName = null;
if (model.Photo != null)
{
string uploadsFolder = Path.Combine(_webHostEnvironment.WebRootPath, "Images", "Uploads");
uniqueFileName = Guid.NewGuid().ToString() + "_" + model.Photo.FileName;
string filePath = Path.Combine(uploadsFolder, uniqueFileName);
model.Photo.CopyTo(new FileStream(filePath, FileMode.Create));
}
Book book = new Book
{
Title = model.Title,
Author = model.Author,
Format = model.Format,
PubYear = model.PubYear,
Condition = model.Condition,
ImageUrl = uniqueFileName
};
var currentUser = await _userManager.FindByNameAsync(User.Identity.Name);
book.appUserId = currentUser.Id;
repo.AddBook(book);
return(RedirectToAction(nameof(Index)));
}
return(View(model));
}
public async Task <ActionResult> Create(CreateBookViewModel model)
{
try
{
if (!ModelState.IsValid)
{
return(View(model));
}
var category = UnitOfWork.CategoryRepository.Get(x => x.Id == model.CategoryId);
var user = await UserManager.FindByIdAsync(GetUserId());
var newBook = new Book()
{
Name = model.Name,
Description = model.Description,
Author = model.Author,
ReleaseYear = model.ReleaseYear,
Draft = model.Draft,
Category = category,
User = user
};
UnitOfWork.BookRepository.Add(newBook);
if (UnitOfWork.Complete() > 0)
{
return(RedirectToAction(nameof(Index)));
}
return(View(model));
}
catch
{
return(View(model));
}
}
public async Task <IActionResult> CreateBooks(CreateBookViewModel vm)
{
try
{
if (ModelState.IsValid)
{
var result = await _bookService.createBook(new DataAccessLayer.Entities.Books {
BookAuthor = vm.BookAuthor, bookName = vm.bookName, bookTitle = vm.bookTitle
}, vm.Description, vm.yearPublished, vm.bookAbstract, vm.versionTitle, vm.Amount);
if (result)
{
_logger.LogInformation("New Book has been Created with");
ViewData["CreateBookMessage"] = "New Book has been created successfully";//TODO: Make all this literals to enums to avoid too much strings
return(View());
}
}
}
catch (Exception ex)
{
ViewData["CreateBookMessageError"] = ex.Message;
_logger.LogError(ex, "An Error has occured, Test May Not be created");
}
return(View());
}
// GET: Authors/Create
public ActionResult Create()
{
CreateBookViewModel vm = new CreateBookViewModel();
vm.Authors = db.Authors.ToList();
return(View(vm));
}
// GET: Books/Create
public ActionResult Create()
{
var model = new CreateBookViewModel();
ViewBag.GenreId = new SelectList(db.Genres, "Id", "Name");
return(View(model));
}
public ActionResult Create(CreateBookViewModel model)
{
if (ModelState.IsValid)
{
var book = new Book()
{
Author = model.Author,
Content = model.Content,
Title = model.Title,
Category = this.db.Categories.GetById(model.CategoryId)
};
this.db.Books.Add(book);
this.db.SaveChanges();
return(RedirectToAction("All"));
}
ViewBag.Categories = this.db.Categories.All().ToList()
.Select(cat => new SelectListItem()
{
Text = cat.Name,
Value = cat.Id.ToString()
});
return(View());
}
public async Task <IActionResult> Create(CreateBookViewModel book)
{
if (book.History == null)
{
if (book.History == null)
{
if (book.BookFile != null && book.CoverImageFile != null)
{
Helpers.Methods.CreateItem(book.BookFile, true);
Helpers.Methods.CreateItem(book.CoverImageFile);
}
else
{
return(NotFound());
}
var item = CreateNewBook(book);
_context.Add(item);
await _context.SaveChangesAsync();
return(Redirect("/Home"));
}
}
return(Redirect("/Home"));
}
public ActionResult Create(CreateBookViewModel createBookViewModel)
{
if (ModelState.IsValid)
{
try
{
var book = new Book()
{
Title = createBookViewModel.Book.Title
};
foreach (var authorId in createBookViewModel.SelectedAuthors)
{
book.AuthorId.Add(authorId);
}
bookService.CreateBook(book);
return(RedirectToAction(nameof(Index)));
}
catch
{
return(View());
}
}
return(View());
}
public async Task CreateBook_WithValidModel_ShouldAddBookToDb()
{
//Assert
var db = this.SetDb();
var repo = new Repository <Book>(db);
var service = new BookService(repo, this.Mapper, null);
var model = new CreateBookViewModel
{
Author = "Ema Tor",
Title = "Cook with pleasure",
CoverUrl = "https://res.cloudinary.com/cakeit/image/upload/v1546032585/DairyFreeRecipes.jpg",
Description = "This book offers you an array of delicious dairy-free delights.",
DownloadUrl = "https://res.cloudinary.com/cakeit/image/upload/v1545921235/50_Dairy-Free_Recipes.pdf",
Pages = 23
};
//Act
await service.CreateBook(model);
//Assert
Assert.NotEmpty(repo.All());
}
private async Task SeedBook(CakeItDbContext db)
{
var repo = new Repository <Book>(db);
var service = new BookService(repo, this.Mapper, null);
var modelA = new CreateBookViewModel
{
Author = "Ema Tor",
Title = "Cook with pleasure",
CoverUrl = "https://res.cloudinary.com/cakeit/image/upload/v1546032585/DairyFreeRecipes.jpg",
Description = "This book offers you an array of delicious dairy-free delights.",
DownloadUrl = "https://res.cloudinary.com/cakeit/image/upload/v1545921235/50_Dairy-Free_Recipes.pdf",
Pages = 23
};
await service.CreateBook(modelA);
var modelB = new CreateBookViewModel
{
Author = "Various",
Title = "Holiday Baking Experimente",
CoverUrl = "https://res.cloudinary.com/cakeit/image/upload/v1546028277/HBE.pdf",
Description = "This book offers you an array of delicious dairy-free delights.",
DownloadUrl = "https://res.cloudinary.com/cakeit/image/upload/v1546032518/HoliayBakingExperiment.jpg",
Pages = 23
};
await service.CreateBook(modelB);
}
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Book book = bookManager.Find(x => x.Id == id.Value);
if (book == null)
{
return(HttpNotFound());
}
ViewBag.Yazar = authorManager.List();
ViewBag.Kategori = categoryManager.List();
ViewBag.Yayınevi = publisherManager.List();
CreateBookViewModel createBookViewModel = new CreateBookViewModel()
{
Id = book.Id,
Category = book.Category.Id,
Author = book.Author.Id,
Publisher = book.Publisher.Id,
Name = book.Name,
Page = book.Page,
Year = book.Year
};
return(View(createBookViewModel));
}
/// <summary>
/// CreateAsync
/// </summary>
/// <param name="model"></param>
/// <param name="imagePath"></param>
/// <param name="pdfPath"></param>
/// <returns></returns>
public async Task CreateAsync(CreateBookViewModel model, string imagePath, string pdfPath)
{
var book = new Entities.Book
{
Available = model.Available,
Description = model.Description,
Language = model.Language,
Percent = model.Percent,
Price = model.Price,
Title = model.Title,
AvailableCount = model.AvailableCount,
CategoryId = model.CategoryId,
HasPdf = pdfPath != null,
PdfPath = pdfPath,
ImagePath = imagePath,
PagesNumber = model.PagesNumber,
PublishYear = model.PublishYear,
ISBN = model.ISBN
};
await _context.Books.AddAsync(book);
await _context.SaveChangesAsync();
var bookAuthors = new List <BookAuthor>();
foreach (var id in model.AuthorsId)
{
bookAuthors.Add(new BookAuthor {
BookId = book.Id, AuthorId = id
});
}
await _context.BookAuthors.AddRangeAsync(bookAuthors);
await _context.SaveChangesAsync();
}
public IActionResult Create()
{
AddPublishersListInViewBag();
var createBookViewModel = new CreateBookViewModel();
return(View(createBookViewModel));
}
public async Task <IActionResult> UpdateBooksAsync([FromBody] CreateBookViewModel model)
{
var result = _unitOfWork.Books.Find(b => b.ISBN == model.ISBN).FirstOrDefault();
_mapper.Map(model, result);
await _unitOfWork.Complete();
return(Ok());
}
public async Task <IActionResult> AddBooksAsync([FromBody] CreateBookViewModel model)
{
var res = _mapper.Map <Book>(model);
await _unitOfWork.Books.AddAsync(res);
await _unitOfWork.Complete();
return(Ok());
}
public BookResponse AddBook(CreateBookViewModel book)
{
if (book.ListOfTags.Count == 0)
{
throw new CustomException("Invalid empty Book Tag list you Must enter at least one Tag");
}
return(_mapper.Map <Book, BookResponse>(_bookRepository.AddBook(book)));
}
public CreateBookViewModel BeforeCreateBook()
{
var tempBookModel = new CreateBookViewModel();
tempBookModel.ListGeners = new SelectList(_generRepository.Get(), "Id", "Genre");
tempBookModel.DateInsert = DateTime.Now.Date;
return(tempBookModel);
}
public IActionResult Create(CreateBookViewModel viewModel)
{
if (ModelState.IsValid)
{
var bookResult = OnPostCreateBook(viewModel);
return(RedirectToAction("Details", "Book", new { id = bookResult.Id }));
}
return(this.View(viewModel));
}
public ActionResult Create()
{
var model = new CreateBookViewModel();
model.Categories = _db.Categories.Select(c => new SelectListItem {
Text = c.Name, Value = c.Id.ToString()
});
return(View(model));
}
public async Task <ActionResult> Create(CreateBookViewModel book)
{
if (ModelState.IsValid)
{
await bookService.CreateBookAsync(book);
return(RedirectToAction("Index", "Base"));
}
return(View(book));
}
private Book OnPostCreateBook(CreateBookViewModel viewModel)
{
var bookAuthor = this.authorService.GetAuthorByName(viewModel.AuthorFirstName, viewModel.AuthorLastName);
var book = this.mapper.Map <Book>(viewModel);
book.AuthorId = bookAuthor.Id;
this.context.Books.Add(book);
this.context.SaveChanges();
return(book);
}
public ActionResult Create(CreateBookViewModel book)
{
ViewBag.Authors = aAct.GetListNickName();
var result = bAct.Add(book.Title, book.AuthorId, book.Price, book.DatePrint, book.Publishing, book.Edition);
ViewBag.Result = result;
return(View());
}
public ActionResult Create()
{
CreateBookViewModel viewModel = new CreateBookViewModel
{
Authors = new SelectList(_authorService.GetAllAuthors(), "Id", "Name"),
Genres = new SelectList(_categoryService.GetCategories(), "Id", "CategoryName")
};
return(View(viewModel));
}
public ActionResult Create(CreateBookViewModel model)
{
if (!ModelState.IsValid)
{
return View(model);
}
var result = commandExecutor.Execute(new CreateBookCommand(model));
if (result.IsSuccess())
{
return RedirectToAction("Index", new { id = result.ReturnValue.Book.Id, fromLibrary = result.ReturnValue.Library.Id });
}
ModelState.AddModelError("", result.CombinedErrors());
return View(model);
}
public void Create_PostsModelStateIsInvalid_ReturnsViewWithPassedMessage()
{
controller.ModelState.AddModelError("fel", "felet");
var viewModel = new CreateBookViewModel();
var result = (ViewResult)controller.Create(viewModel);
Assert.That(result.ViewName, Is.EqualTo(""));
Assert.That(result.Model, Is.SameAs(viewModel));
}
