public async Task <ActionResult> Create(Book book)
{
try
{
if (ModelState.IsValid)
{
_respository.AddBook(book);
await _respository.SaveAsync();
return(RedirectToAction("Index"));
}
return(View(book));
}
catch
{
return(View(book));
}
}
public async Task <ActionResult <BookMongoDTO> > AddBook([FromBody] BookMongoDTO book)
{
var author = await writersRepository.FindWriter(book.Writer.Id);
if (author != null)
{
book.Writer = author;
}
else
{
var addWriterResult = writersRepository.AddWriter(book.Writer);
if (addWriterResult == null)
{
return(BadRequest());
}
}
var addBookResult = await booksRepository.AddBook(book);
if (addBookResult != null)
{
return(Ok(CreateLinksForBook(addBookResult)));
}
else
{
await writersRepository.DeleteWriter(book.Writer.Id);
return(BadRequest());
}
}
public async Task <IActionResult> CreateBookCollection([FromBody] IEnumerable <BookForCreation> bookCollection)
{
// Map from entities
var bookEntities = _mapper.Map <IEnumerable <Entities.Book> >(bookCollection);
// loop and save
foreach (var bookEntity in bookEntities)
{
_booksRepository.AddBook(bookEntity);
}
;
// save changes
await _booksRepository.SaveChangesAsync();
// form and return one collection
var booksToReturn = await _booksRepository.GetBooksAsync(
bookEntities.Select(b => b.Id)
.ToList());
var bookIds = string.Join(",", booksToReturn.Select(a => a.Id));
return(CreatedAtRoute("GetBookCollection",
new { bookIds },
booksToReturn));
}
public ActionResult Create(AddBookFormModel addBookForm)
{
try
{
var author = new Author()
{
FirstName = addBookForm.AuthorFirstName,
LastName = addBookForm.AuthorLastName
};
var book = new Book
{
Title = addBookForm.Title,
AuthorId = author.Id,
YearPublished = addBookForm.YearPublished,
Genre = addBookForm.Genre,
//Location = addBookForm.Location
};
repository.AddBook(book, author);
return(RedirectToAction("Index"));
}
catch
{
return(View());
}
}
public IActionResult Edit(Book bookReturned)
{
//If model is not valid return to inform the user
if (!ModelState.IsValid)
{
return(View());
}
//If book has valid id, update it, else create it.
if (bookReturned.BookId > 0)
{
booksRepository.UpdateBook(bookReturned);
return(RedirectToAction("Index", "Home"));
}
else
{
bookReturned.UserName = User.Identity.Name;
switch (bookReturned.Status)
{
case BookStatus.ToRead:
booksRepository.AddBook(bookReturned);
return(RedirectToAction("Index", "Home"));
case BookStatus.CurrentlyReading:
booksRepository.AddBook(bookReturned);
//Ask for initial log of book
return(RedirectToAction("Create", "ReadLogs",
new { id = bookReturned.BookId, bookName = bookReturned.Name }));
case BookStatus.Read:
//Create finish log for book
var finishLog = new ReadLog()
{
Book = bookReturned, LogDate = DateTime.Today, PageNumber = bookReturned.NumberOfPages
};
//Add log and save book
bookReturned.ReadLogs.Add(finishLog);
booksRepository.AddBook(bookReturned);
return(RedirectToAction("Index", "Home"));
default:
return(RedirectToAction("Index", "Home"));
}
}
}
/// <summary>
/// post book .
/// </summary>
/// <param name="book"></param>
public async Task <BookDTO> PostBook(BookDTO book)
{
try {
return(await _booksRepository.AddBook(_mapper.Map <BookCollection>(book)));
}
catch {
throw;
}
}
public IActionResult OnPost()
{
if (ModelState.IsValid)
{
catalog.AddBook(Book);
Books = catalog.GetAllBooks();
}
return(Page());
}
public void AddDemoBooks()
{
var jr = new Author("Joanne", "Rowling");
var leo = new Author("Leo", "Tolstoy");
var bs = new Author("Brandon", "Sanderson");
var rm = new Author("Robert", "Martin");
_authorsRepository.AddAuthor(jr);
_authorsRepository.AddAuthor(leo);
_authorsRepository.AddAuthor(bs);
_authorsRepository.AddAuthor(rm);
_booksRepository.AddBook(new Book("Harry Potter", 455, new DateTime(2005, 1, 1), "9780545010221", new[] { jr }));
_booksRepository.AddBook(new Book("War and Peace", 1311, new DateTime(2011, 1, 1), "9781400079988", new[] { leo }));
_booksRepository.AddBook(new Book("Mistborn", 670, new DateTime(2013, 1, 1), "9780765365439", new[] { bs }, "Tor Books"));
_booksRepository.AddBook(new Book("Oathbringer", 1051, new DateTime(2017, 1, 1), "9781250297143", new[] { bs }, "Tor Books"));
_booksRepository.AddBook(new Book("Clean Code", 522, new DateTime(2008, 1, 1), "9780132350884", new[] { rm }, "Эксмо"));
}
public IActionResult OnPost()
{
if (!ModelState.IsValid)
{
return(Page());
}
repository.AddBook(Book);
Books = repository.GetAllBooks();
return(RedirectToPage("CreateBook"));
}
public ActionResult AddBook(Book book)
{
if (ModelState.IsValid)
{
_booksRepository.AddBook(book);
_booksRepository.Save();
return(RedirectToAction("Home", "Books"));
}
return(View(book));
}
public async Task <IActionResult> CreateBook(BookForCreation bookForCreation)
{
var bookEntity = _mapper.Map <Entities.Book>(bookForCreation);
_booksRepository.AddBook(bookEntity);
await _booksRepository.SaveChangesAsync();
await _booksRepository.GetBookAsync(bookEntity.Id);
return(CreatedAtRoute("GetBook", new { id = bookEntity.Id }, bookEntity));
}
public IActionResult OnPost(Book book)
{
if (ModelState.IsValid)
{
m_booksRepo.AddBook(book);
return(RedirectToPage("/Books/Index"));
}
//Book = book; looks like it is not needed
return(Page());
}
public async Task <ActionResult <BookDto> > CreateBook(BookForCreationDto bookForCreation)
{
var book = _mapper.Map <Book>(bookForCreation);
_booksRepository.AddBook(book);
await _booksRepository.SaveChangesAsync();
await _booksRepository.GetBookAsync(book.Id);
return(CreatedAtAction(nameof(GetBook), new { id = book.Id }, _mapper.Map <BookDto>(book)));
}
public ActionResult Create(Models.BD.Books book)
{
if (ModelState.IsValid)
{
booksRepository.AddBook(book);
booksRepository.Save();
return(RedirectToAction("BookIndex"));
}
return(View(book));
}
public async Task <bool> AddBook(Book book)
{
if (book.Id == 0)
{
throw new Exception("Please provide a valid UserId.");
}
var resBook = _mapper.Map <DataModels.Book>(book);
var resBookStore = _mapper.Map <DataModels.BookStore>(book);
return(await _booksRepo.AddBook(resBook, resBookStore));
}
public async Task <IActionResult> CreateBook([FromBody] BookForCreation book) //deserialize the request body to BookForCreation instance
{ //since the book to create is not the Models.Books nor Entities.Book. so create a class "BookForCreation"
var bookEntity = _mapper.Map <Entities.Book>(book);
_booksRepository.AddBook(bookEntity);
await _booksRepository.SaveChangesAsync();
//fetch (refetch) the book from data store, including the author
await _booksRepository.GetBookAsync(bookEntity.Id);
return(CreatedAtRoute("GetBook", new { id = bookEntity.Id }, bookEntity));
}
public IActionResult Create(Book book)
{
if (ModelState.IsValid)
{
var bookIdToBeSabed = _booksRepository.AddBook(book);
return(RedirectToAction("Details", new { id = bookIdToBeSabed }));
}
else
{
ViewBag.Genres = ViewBag.Genres = GetGenres();
return(View(book));
}
}
public void AddBook(CreateBookData data)
{
var authors = _authorsRepository.GetAuthors(data.AuthorIds);
var book = new Book(data.Title,
data.PageNumber,
new DateTime(data.PublishYear, 1, 1),
data.ISBN,
authors,
data.Publisher
);
_booksRepository.AddBook(book);
}
public async Task <IActionResult> CreateBook(BookForCreation bookForCreation)
{
var book = _mapper.Map <Entities.Book>(bookForCreation);
_booksRepository.AddBook(book);
await _booksRepository.SaveChangesAsync();
await _booksRepository.GetBookAsync(book.Id); //loads author details into the context
return(CreatedAtRoute("GetBook", new { id = book.Id }, book));
}
public async Task <IActionResult> CreateBook([FromBody] BookForCreation book)
{
var bookEntity = _mapper.Map <Entities.Book>(book);
_booksRepository.AddBook(bookEntity);
// you have to add validaiton here
await _booksRepository.SaveChangesAsync();
return(CreatedAtRoute("GetBook",
new { id = bookEntity.Id },
bookEntity));
}
public async Task <IActionResult> CreateBookCollection(IEnumerable <BookForCreationDto> booksForCreation)
{
var books = _mapper.Map <IEnumerable <Book> >(booksForCreation);
foreach (var it in books)
{
_booksRepository.AddBook(it);
}
await _booksRepository.SaveChangesAsync();
return(Ok());
}
public async Task <IActionResult> CreateBook([FromBody] BookForCreation book)
{
var bookEntity = _mapper.Map <Entities.Book>(book);
_booksRepository.AddBook(bookEntity);
await _booksRepository.SaveChangesAsync();
// Fetch (refetch) the book from the data store, including the author.
await _booksRepository.GetBookAsync(bookEntity.Id);
return(CreatedAtRoute("GetBook", new { id = bookEntity.Id }, bookEntity));
}
public async Task <IActionResult> CreateBooksCollection(IEnumerable <BookForCreationDto> booksForCreationDtos)
{
var bookEntities = _mapper.Map <IEnumerable <Book> >(booksForCreationDtos);
foreach (var bookEntity in bookEntities)
{
_booksRepository.AddBook(bookEntity);
}
await _booksRepository.SaveChangesAsync();
var bookIds = bookEntities.Select(b => b.Id).ToList();
var booksToReturn = await _booksRepository.GetBooksAsync(bookIds);
return(CreatedAtRoute(nameof(GetBooksCollection), new { bookIds = string.Join(",", bookIds) }, booksToReturn));
}
// POST api/books
public async Task Post(Book newBook)
{
try
{
var book = await _repo.AddBook(newBook);
Context.Response.Headers["Location"] = Url.RouteUrl("GetByIdRoute", new { id = book.Id });
Context.Response.StatusCode = (int)HttpStatusCode.Created;
}
catch (ValidationException ex)
{
Response.StatusCode = (int)HttpStatusCode.NotAcceptable;
await Response.WriteAsync(ex.Message);
}
}
public async Task <IActionResult> CreateBookCollection([FromBody] IEnumerable <BookForCreation> bookCollection)
{
var bookCollectionEntities = _mapper.Map <IEnumerable <Entities.Book> >(bookCollection);
foreach (var bookEntity in bookCollectionEntities)
{
_booksRepository.AddBook(bookEntity);
}
await _booksRepository.SaveChangesAsync();
var books = await _booksRepository.GetBooksAsync();;
return(Ok(books));
}
public async Task <IActionResult> CreateBook([FromBody] BookForCreation book)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var bookEntity = _mapper.Map <Entities.Book>(book);
_booksRepository.AddBook(bookEntity);
await _booksRepository.SaveChangesAsync();
await _booksRepository.GetBookAsync(bookEntity.Id);
return(CreatedAtRoute("GetBook", new { bookEntity.Id }, bookEntity));
}
public async Task <IActionResult> CreateBookCollection(IEnumerable <BookForCreation> bookCollection, [FromServices] IMapper mapper)
{
var bookEntities = mapper.Map <IEnumerable <Entities.Book> >(bookCollection);
foreach (var bookEntity in bookEntities)
{
booksRepository.AddBook(bookEntity);
}
await booksRepository.SaveChangesAsync();
var bookIds = bookEntities.Select(x => x.Id);
var booksToReturn = await this.booksRepository.GetBooksAsync(bookIds);
return(CreatedAtRoute(nameof(GetBookCollection), new { bookIds = string.Join(",", bookIds) }, booksToReturn));
}
public async Task <IActionResult> CreateBook([FromBody] BookForCreation book)
{
try
{
var bookEntity = _mapper.Map <Entities.Book>(book);
_booksRepository.AddBook(bookEntity);
await _booksRepository.SaveChangesAsync();
return(CreatedAtRoute("GetBook",
new { id = bookEntity.Id },
bookEntity));
}
catch (Exception e)
{
return(NotFound(e.Message));
}
}
public async Task <IActionResult> CreateBookCollection([FromBody] IEnumerable <BookForCreation> bookCollection)
{
var bookEntities = mapper.Map <IEnumerable <Entities.Book> >(bookCollection);
foreach (var bookEntity in bookEntities)
{
booksRepository.AddBook(bookEntity);
}
await booksRepository.SaveChangesAsync();
var booksToReturn = await booksRepository.GetBooksAsync(bookEntities.Select(b => b.Id).ToList());
var bookIds = string.Join(",", booksToReturn.Select(a => a.Id));
return(CreatedAtRoute("GetBookCollection", new { bookIds }, booksToReturn)); // new { bookIds = bookIds } for name
}
public ActionResult Create([Bind(Include = "LibroId,NombreLibro,Autor,ISBN")] Libro libro)
{
try
{
if (ModelState.IsValid)
{
bookRepository.AddBook(libro);
bookRepository.Save();
return(RedirectToAction("Index"));
}
}
catch (DataException)
{
ModelState.AddModelError(string.Empty, "No fue posible agregar los cambios. Por favor, intentarlo de nuevo, y si el problema persiste contacta al administrador.");
}
return(View(libro));
}
